(Alpenglow) Allow creating v4 account in genesis, upstream Consensus Pool.

local-cluster/src/local_cluster.rs

@@ -312,6 +312,7 @@ impl LocalCluster {
             &keys_in_genesis,
             stakes_in_genesis,
             config.cluster_type,
+            false,
         );
         genesis_config.accounts.extend(
             config

program-test/src/lib.rs

@@ -806,6 +806,7 @@ impl ProgramTest {
             &bootstrap_validator_pubkey,
             &voting_keypair.pubkey(),
             &Pubkey::new_unique(),
+            None,
             bootstrap_validator_stake_lamports,
             42,
             fee_rate_governor,

programs/sbf/tests/programs.rs

@@ -1661,6 +1661,7 @@ fn get_stable_genesis_config() -> GenesisConfigInfo {
         &validator_pubkey,
         &voting_keypair.pubkey(),
         &stake_pubkey,
+        None,
         bootstrap_validator_stake_lamports(),
         42,
         FeeRateGovernor::new(0, 0), // most tests can't handle transaction fees

programs/stake/src/stake_state.rs

@@ -12,7 +12,7 @@ use {
     solana_rent::Rent,
     solana_sdk_ids::stake::id,
     solana_stake_interface::stake_flags::StakeFlags,
-    solana_vote_interface::state::VoteStateV3,
+    solana_vote_interface::state::{VoteStateV3, VoteStateV4},
 };
 
 // utility function, used by Stakes, tests
@@ -40,15 +40,10 @@ pub fn meta_from(account: &AccountSharedData) -> Option<Meta> {
     from(account).and_then(|state: StakeStateV2| state.meta())
 }
 
-fn new_stake(
-    stake: u64,
-    voter_pubkey: &Pubkey,
-    vote_state: &VoteStateV3,
-    activation_epoch: Epoch,
-) -> Stake {
+fn new_stake(stake: u64, voter_pubkey: &Pubkey, credits: u64, activation_epoch: Epoch) -> Stake {
     Stake {
         delegation: Delegation::new(voter_pubkey, stake, activation_epoch),
-        credits_observed: vote_state.credits(),
+        credits_observed: credits,
     }
 }
 
@@ -93,6 +88,25 @@ pub fn create_account(
         rent,
         lamports,
         Epoch::MAX,
+        false,
+    )
+}
+
+pub fn create_alpenglow_account(
+    authorized: &Pubkey,
+    voter_pubkey: &Pubkey,
+    vote_account: &AccountSharedData,
+    rent: &Rent,
+    lamports: u64,
+) -> AccountSharedData {
+    do_create_account(
+        authorized,
+        voter_pubkey,
+        vote_account,
+        rent,
+        lamports,
+        Epoch::MAX,
+        true,
     )
 }
 
@@ -103,10 +117,17 @@ fn do_create_account(
     rent: &Rent,
     lamports: u64,
     activation_epoch: Epoch,
+    is_alpenglow: bool,
 ) -> AccountSharedData {
     let mut stake_account = AccountSharedData::new(lamports, StakeStateV2::size_of(), &id());
 
-    let vote_state = VoteStateV3::deserialize(vote_account.data()).expect("vote_state");
+    let credits = if is_alpenglow {
+        let vote_state_v4 = VoteStateV4::deserialize(vote_account.data(), voter_pubkey).unwrap();
+        vote_state_v4.epoch_credits.last().map_or(0, |(_, c, _)| *c)
+    } else {
+        let vote_state = VoteStateV3::deserialize(vote_account.data()).expect("vote_state");
+        vote_state.credits()
+    };
 
     let rent_exempt_reserve = rent.minimum_balance(stake_account.data().len());
 
@@ -120,7 +141,7 @@ fn do_create_account(
             new_stake(
                 lamports - rent_exempt_reserve, // underflow is an error, is basically: assert!(lamports > rent_exempt_reserve);
                 voter_pubkey,
-                &vote_state,
+                credits,
                 activation_epoch,
             ),
             StakeFlags::empty(),

runtime/Cargo.toml

@@ -176,6 +176,7 @@ solana-version = { workspace = true }
 solana-vote = { workspace = true }
 solana-vote-interface = { workspace = true }
 solana-vote-program = { workspace = true }
+solana-votor-messages = { workspace = true }
 spl-generic-token = { workspace = true }
 static_assertions = { workspace = true }
 strum = { workspace = true, features = ["derive"] }

runtime/src/genesis_utils.rs

@@ -2,6 +2,10 @@ use {
     agave_feature_set::{FeatureSet, FEATURE_NAMES},
     log::*,
     solana_account::{Account, AccountSharedData},
+    solana_bls_signatures::{
+        keypair::Keypair as BLSKeypair, pubkey::PubkeyCompressed as BLSPubkeyCompressed,
+        Pubkey as BLSPubkey,
+    },
     solana_cluster_type::ClusterType,
     solana_feature_gate_interface::{self as feature, Feature},
     solana_fee_calculator::FeeRateGovernor,
@@ -15,7 +19,9 @@ use {
     solana_stake_interface::state::StakeStateV2,
     solana_stake_program::stake_state,
     solana_system_interface::program as system_program,
+    solana_vote_interface::state::BLS_PUBLIC_KEY_COMPRESSED_SIZE,
     solana_vote_program::vote_state,
+    solana_votor_messages::consensus_message::BLS_KEYPAIR_DERIVE_SEED,
     std::borrow::Borrow,
 };
 
@@ -99,6 +105,21 @@ pub fn create_genesis_config_with_vote_accounts(
         voting_keypairs,
         stakes,
         ClusterType::Development,
+        false,
+    )
+}
+
+pub fn create_genesis_config_with_alpenglow_vote_accounts(
+    mint_lamports: u64,
+    voting_keypairs: &[impl Borrow<ValidatorVoteKeypairs>],
+    stakes: Vec<u64>,
+) -> GenesisConfigInfo {
+    create_genesis_config_with_vote_accounts_and_cluster_type(
+        mint_lamports,
+        voting_keypairs,
+        stakes,
+        ClusterType::Development,
+        true,
     )
 }
 
@@ -107,6 +128,7 @@ pub fn create_genesis_config_with_vote_accounts_and_cluster_type(
     voting_keypairs: &[impl Borrow<ValidatorVoteKeypairs>],
     stakes: Vec<u64>,
     cluster_type: ClusterType,
+    is_alpenglow: bool,
 ) -> GenesisConfigInfo {
     assert!(!voting_keypairs.is_empty());
     assert_eq!(voting_keypairs.len(), stakes.len());
@@ -115,12 +137,23 @@ pub fn create_genesis_config_with_vote_accounts_and_cluster_type(
     let voting_keypair = voting_keypairs[0].borrow().vote_keypair.insecure_clone();
 
     let validator_pubkey = voting_keypairs[0].borrow().node_keypair.pubkey();
+    let validator_bls_pubkey = if is_alpenglow {
+        let bls_keypair = BLSKeypair::derive_from_signer(
+            &voting_keypairs[0].borrow().vote_keypair,
+            BLS_KEYPAIR_DERIVE_SEED,
+        )
+        .unwrap();
+        Some(bls_pubkey_to_compressed_bytes(&bls_keypair.public))
+    } else {
+        None
+    };
     let genesis_config = create_genesis_config_with_leader_ex(
         mint_lamports,
         &mint_keypair.pubkey(),
         &validator_pubkey,
         &voting_keypairs[0].borrow().vote_keypair.pubkey(),
         &voting_keypairs[0].borrow().stake_keypair.pubkey(),
+        validator_bls_pubkey,
         stakes[0],
         VALIDATOR_LAMPORTS,
         FeeRateGovernor::new(0, 0), // most tests can't handle transaction fees
@@ -143,14 +176,41 @@ pub fn create_genesis_config_with_vote_accounts_and_cluster_type(
 
         // Create accounts
         let node_account = Account::new(VALIDATOR_LAMPORTS, 0, &system_program::id());
-        let vote_account = vote_state::create_account(&vote_pubkey, &node_pubkey, 0, *stake);
-        let stake_account = Account::from(stake_state::create_account(
-            &stake_pubkey,
-            &vote_pubkey,
-            &vote_account,
-            &genesis_config_info.genesis_config.rent,
-            *stake,
-        ));
+        let vote_account = if is_alpenglow {
+            let bls_keypair = BLSKeypair::derive_from_signer(
+                &validator_voting_keypairs.borrow().vote_keypair,
+                BLS_KEYPAIR_DERIVE_SEED,
+            )
+            .unwrap();
+            let bls_pubkey_compressed = bls_pubkey_to_compressed_bytes(&bls_keypair.public);
+            vote_state::create_v4_account_with_authorized(
+                &node_pubkey,
+                &vote_pubkey,
+                &vote_pubkey,
+                Some(bls_pubkey_compressed),
+                0,
+                *stake,
+            )
+        } else {
+            vote_state::create_account(&vote_pubkey, &node_pubkey, 0, *stake)
+        };
+        let stake_account = if is_alpenglow {
+            Account::from(stake_state::create_alpenglow_account(
+                &stake_pubkey,
+                &vote_pubkey,
+                &vote_account,
+                &genesis_config_info.genesis_config.rent,
+                *stake,
+            ))
+        } else {
+            Account::from(stake_state::create_account(
+                &stake_pubkey,
+                &vote_pubkey,
+                &vote_account,
+                &genesis_config_info.genesis_config.rent,
+                *stake,
+            ))
+        };
 
         let vote_account = Account::from(vote_account);
 
@@ -204,6 +264,7 @@ pub fn create_genesis_config_with_leader_with_mint_keypair(
         validator_pubkey,
         &voting_keypair.pubkey(),
         &Pubkey::new_unique(),
+        None,
         validator_stake_lamports,
         VALIDATOR_LAMPORTS,
         FeeRateGovernor::new(0, 0), // most tests can't handle transaction fees
@@ -266,34 +327,64 @@ pub fn activate_feature(genesis_config: &mut GenesisConfig, feature_id: Pubkey)
     );
 }
 
+pub fn bls_pubkey_to_compressed_bytes(
+    bls_pubkey: &BLSPubkey,
+) -> [u8; BLS_PUBLIC_KEY_COMPRESSED_SIZE] {
+    let key = BLSPubkeyCompressed::try_from(bls_pubkey).unwrap();
+    bincode::serialize(&key).unwrap().try_into().unwrap()
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn create_genesis_config_with_leader_ex_no_features(
     mint_lamports: u64,
     mint_pubkey: &Pubkey,
     validator_pubkey: &Pubkey,
     validator_vote_account_pubkey: &Pubkey,
     validator_stake_account_pubkey: &Pubkey,
+    validator_bls_pubkey: Option<[u8; BLS_PUBLIC_KEY_COMPRESSED_SIZE]>,
     validator_stake_lamports: u64,
     validator_lamports: u64,
     fee_rate_governor: FeeRateGovernor,
     rent: Rent,
     cluster_type: ClusterType,
     mut initial_accounts: Vec<(Pubkey, AccountSharedData)>,
 ) -> GenesisConfig {
-    let validator_vote_account = vote_state::create_account(
-        validator_vote_account_pubkey,
-        validator_pubkey,
-        0,
-        validator_stake_lamports,
-    );
+    let is_alpenglow = validator_bls_pubkey.is_some();
+    let validator_vote_account = if let Some(bls_pubkey_compressed) = validator_bls_pubkey {
+        vote_state::create_v4_account_with_authorized(
+            validator_pubkey,
+            validator_vote_account_pubkey,
+            validator_vote_account_pubkey,
+            Some(bls_pubkey_compressed),
+            0,
+            validator_stake_lamports,
+        )
+    } else {
+        vote_state::create_account(
+            validator_vote_account_pubkey,
+            validator_pubkey,
+            0,
+            validator_stake_lamports,
+        )
+    };
 
-    let validator_stake_account = stake_state::create_account(
-        validator_stake_account_pubkey,
-        validator_vote_account_pubkey,
-        &validator_vote_account,
-        &rent,
-        validator_stake_lamports,
-    );
+    let validator_stake_account = if is_alpenglow {
+        stake_state::create_alpenglow_account(
+            validator_stake_account_pubkey,
+            validator_vote_account_pubkey,
+            &validator_vote_account,
+            &rent,
+            validator_stake_lamports,
+        )
+    } else {
+        stake_state::create_account(
+            validator_stake_account_pubkey,
+            validator_vote_account_pubkey,
+            &validator_vote_account,
+            &rent,
+            validator_stake_lamports,
+        )
+    };
 
     initial_accounts.push((
         *mint_pubkey,
@@ -342,6 +433,7 @@ pub fn create_genesis_config_with_leader_ex(
     validator_pubkey: &Pubkey,
     validator_vote_account_pubkey: &Pubkey,
     validator_stake_account_pubkey: &Pubkey,
+    validator_bls_pubkey: Option<[u8; BLS_PUBLIC_KEY_COMPRESSED_SIZE]>,
     validator_stake_lamports: u64,
     validator_lamports: u64,
     fee_rate_governor: FeeRateGovernor,
@@ -355,6 +447,7 @@ pub fn create_genesis_config_with_leader_ex(
         validator_pubkey,
         validator_vote_account_pubkey,
         validator_stake_account_pubkey,
+        validator_bls_pubkey,
         validator_stake_lamports,
         validator_lamports,
         fee_rate_governor,

test-validator/src/lib.rs

@@ -927,6 +927,7 @@ impl TestValidator {
             &validator_identity.pubkey(),
             &validator_vote_account.pubkey(),
             &validator_stake_account.pubkey(),
+            None,
             validator_stake_lamports,
             validator_identity_lamports,
             config.fee_rate_governor.clone(),

votor/src/commitment.rs

@@ -0,0 +1,7 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum AlpenglowCommitmentError {
+    #[error("Failed to send commitment data, channel disconnected")]
+    ChannelDisconnected,
+}