local-cluster: add migration test and VoteStateV4 hack

Author: AshwinSekar

Cargo.lock

@@ -11,6 +11,7 @@ readme = false
 
 [features]
 frozen-abi = ["dep:solana-frozen-abi", "dep:solana-frozen-abi-macro"]
+dev-context-only-utils = []
 
 [dependencies]
 ahash = { workspace = true }
@@ -22,6 +23,7 @@ solana-frozen-abi-macro = { workspace = true, optional = true, features = [
     "frozen-abi",
 ] }
 solana-hash = { workspace = true }
+solana-keypair = { workspace = true }
 solana-pubkey = { workspace = true, default-features = false }
 solana-sha256-hasher = { workspace = true }
 solana-svm-feature-set = { workspace = true }

feature-set/Cargo.toml

@@ -1099,7 +1099,17 @@ pub mod formalize_loaded_transaction_data_size {
 }
 
 pub mod alpenglow {
+    use {solana_keypair::Keypair, std::sync::LazyLock};
+
+    pub static TEST_KEYPAIR: LazyLock<Keypair> = LazyLock::new(|| {
+        Keypair::from_base58_string("2Vzd6oTWU4RtM5UmsSyBH3tAhPSi1sKqMeMC8bF1jzHHLBMRhEWtrfmBV4EmwQbGSwkunk5Wy67kXNAL1ZL1xQhR")
+    });
+
+    #[cfg(not(feature = "dev-context-only-utils"))]
     solana_pubkey::declare_id!("mustRekeyVm2QHYB3JPefBiU4BY3Z6JkW2k3Scw5GWP");
+
+    #[cfg(feature = "dev-context-only-utils")]
+    solana_pubkey::declare_id!("8KpruRFrT59jQ9NfFX9DU6j8a1hW7y6xchvZNQ5rxD4P");
 }
 
 pub mod disable_zk_elgamal_proof_program {

feature-set/src/lib.rs

@@ -13,9 +13,14 @@ edition = { workspace = true }
 targets = ["x86_64-unknown-linux-gnu"]
 
 [features]
-dev-context-only-utils = ["solana-core/dev-context-only-utils"]
+dev-context-only-utils = [
+    "solana-core/dev-context-only-utils",
+    "agave-feature-set/dev-context-only-utils",
+    "solana-votor-messages/dev-context-only-utils",
+]
 
 [dependencies]
+agave-feature-set = { workspace = true }
 bincode = { workspace = true }
 crossbeam-channel = { workspace = true }
 itertools = { workspace = true }
@@ -34,6 +39,7 @@ solana-connection-cache = { workspace = true }
 solana-core = { workspace = true }
 solana-entry = { workspace = true }
 solana-epoch-schedule = { workspace = true }
+solana-feature-gate-interface = { workspace = true }
 solana-genesis-config = { workspace = true }
 solana-gossip = { workspace = true }
 solana-hard-forks = { workspace = true }

local-cluster/Cargo.toml

@@ -69,7 +69,9 @@ pub const RUST_LOG_FILTER: &str =
 pub const AG_DEBUG_LOG_FILTER: &str =
     "error,solana_core::replay_stage=info,solana_local_cluster=info,local_cluster=info,\
      solana_core::block_creation_loop=trace,solana_votor=trace,\
-     solana_votor::vote_history_storage=info,solana_core::validator=info";
+     solana_votor::vote_history_storage=info,solana_votor::voting_service=info,\
+     solana_core::validator=info, solana_core::consensus=info, \
+     solana_ledger::blockstore_processor=info";
 pub const DEFAULT_NODE_STAKE: u64 = 10 * LAMPORTS_PER_SOL;
 
 pub fn last_vote_in_tower(tower_path: &Path, node_pubkey: &Pubkey) -> Option<(Slot, Hash)> {

local-cluster/src/integration_tests.rs

@@ -58,7 +58,7 @@ use {
     solana_transaction_error::TransportError,
     solana_vote_program::{
         vote_instruction,
-        vote_state::{self, VoteInit},
+        vote_state::{self, VoteInit, VoteStateTargetVersion},
     },
     solana_votor::vote_history_storage::FileVoteHistoryStorage,
     std::{
@@ -75,6 +75,16 @@ use {
 pub const DEFAULT_MINT_LAMPORTS: u64 = 10_000_000 * LAMPORTS_PER_SOL;
 const DUMMY_SNAPSHOT_CONFIG_PATH_MARKER: &str = "dummy";
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AlpenglowMode {
+    /// No alpenglow - creates regular vote accounts (V3)
+    Disabled,
+    /// Full alpenglow - creates V4 vote accounts and activates alpenglow feature
+    Enabled,
+    /// Pre-migration mode - creates V4 vote accounts but does NOT activate alpenglow feature
+    PreMigration,
+}
+
 pub struct ClusterConfig {
     /// The validator config that should be applied to every node in the cluster
     pub validator_configs: Vec<ValidatorConfig>,
@@ -200,17 +210,33 @@ impl LocalCluster {
     }
 
     pub fn new(config: &mut ClusterConfig, socket_addr_space: SocketAddrSpace) -> Self {
-        Self::init(config, socket_addr_space, false)
+        *solana_vote_program::vote_state::TEMP_HARDCODED_TARGET_VERSION
+            .lock()
+            .unwrap() = VoteStateTargetVersion::V3;
+        Self::init(config, socket_addr_space, AlpenglowMode::Disabled)
     }
 
     pub fn new_alpenglow(config: &mut ClusterConfig, socket_addr_space: SocketAddrSpace) -> Self {
-        Self::init(config, socket_addr_space, true)
+        *solana_vote_program::vote_state::TEMP_HARDCODED_TARGET_VERSION
+            .lock()
+            .unwrap() = VoteStateTargetVersion::V4;
+        Self::init(config, socket_addr_space, AlpenglowMode::Enabled)
+    }
+
+    pub fn new_pre_migration_alpenglow(
+        config: &mut ClusterConfig,
+        socket_addr_space: SocketAddrSpace,
+    ) -> Self {
+        *solana_vote_program::vote_state::TEMP_HARDCODED_TARGET_VERSION
+            .lock()
+            .unwrap() = VoteStateTargetVersion::V4;
+        Self::init(config, socket_addr_space, AlpenglowMode::PreMigration)
     }
 
     pub fn init(
         config: &mut ClusterConfig,
         socket_addr_space: SocketAddrSpace,
-        is_alpenglow: bool,
+        alpenglow_mode: AlpenglowMode,
     ) -> Self {
         assert_eq!(config.validator_configs.len(), config.node_stakes.len());
 
@@ -318,6 +344,12 @@ impl LocalCluster {
         let leader_pubkey = leader_keypair.pubkey();
         let leader_node = Node::new_localhost_with_pubkey(&leader_pubkey);
 
+        // For PreMigration mode, we need to create V4 vote accounts but not activate the feature
+        let create_v4_accounts = matches!(
+            alpenglow_mode,
+            AlpenglowMode::Enabled | AlpenglowMode::PreMigration
+        );
+
         let GenesisConfigInfo {
             mut genesis_config,
             mint_keypair,
@@ -327,8 +359,16 @@ impl LocalCluster {
             &keys_in_genesis,
             stakes_in_genesis,
             config.cluster_type,
-            is_alpenglow,
+            create_v4_accounts,
         );
+
+        // Remove the alpenglow feature for PreMigration mode
+        if alpenglow_mode == AlpenglowMode::PreMigration {
+            genesis_config
+                .accounts
+                .remove(&agave_feature_set::alpenglow::id());
+        }
+
         genesis_config.accounts.extend(
             config
                 .additional_accounts

local-cluster/src/local_cluster.rs

@@ -102,6 +102,7 @@ use {
         consensus_message::{
             CertificateType, ConsensusMessage, VoteMessage, BLS_KEYPAIR_DERIVE_SEED,
         },
+        migration::MIGRATION_SLOT_OFFSET,
         vote::Vote,
     },
     std::{
@@ -6211,6 +6212,140 @@ fn test_alpenglow_imbalanced_stakes_catchup() {
     );
 }
 
+fn test_alpenglow_migration(num_nodes: usize) {
+    solana_logger::setup_with_default(AG_DEBUG_LOG_FILTER);
+    let test_name = &format!("test_alpenglow_migration_{num_nodes}");
+
+    let vote_listener_socket = solana_net_utils::bind_to_localhost().unwrap();
+    let vote_listener_addr = vote_listener_socket.try_clone().unwrap();
+    let mut validator_config = ValidatorConfig::default_for_test();
+    validator_config.voting_service_test_override = Some(VotingServiceOverride {
+        additional_listeners: vec![vote_listener_addr.local_addr().unwrap()],
+        alpenglow_port_override: AlpenglowPortOverride::default(),
+    });
+    // Since we don't skip warmup slots and have very small epochs + tight MIGRATION_SLOT_OFFSET
+    // we can't afford any forking due to rolling start
+    validator_config.wait_for_supermajority = Some(0);
+
+    let validator_keys = (0..num_nodes)
+        .map(|i| (Arc::new(keypair_from_seed(&[i as u8; 32]).unwrap()), true))
+        .collect::<Vec<_>>();
+    let node_stakes = vec![DEFAULT_NODE_STAKE; num_nodes];
+
+    let mut cluster_config = ClusterConfig {
+        validator_configs: make_identical_validator_configs(&validator_config, num_nodes),
+        validator_keys: Some(validator_keys),
+        node_stakes: node_stakes.clone(),
+        slots_per_epoch: 2 * MINIMUM_SLOTS_PER_EPOCH,
+        stakers_slot_offset: 2 * MINIMUM_SLOTS_PER_EPOCH,
+        // So we don't have to wait so long
+        skip_warmup_slots: false,
+        ..ClusterConfig::default()
+    };
+
+    // Create local cluster with alpenglow accounts but feature not activated
+    let cluster = LocalCluster::new_pre_migration_alpenglow(
+        &mut cluster_config,
+        SocketAddrSpace::Unspecified,
+    );
+
+    let validator_keys: Vec<Arc<Keypair>> = cluster
+        .validators
+        .values()
+        .map(|v| v.info.keypair.clone())
+        .collect();
+
+    // Send feature activation transaction
+    info!("Sending feature activation transaction");
+    let client = RpcClient::new_socket_with_commitment(
+        cluster.entry_point_info.rpc().unwrap(),
+        CommitmentConfig::processed(),
+    );
+    let faucet_keypair = &cluster.funding_keypair;
+    let feature_keypair = &*agave_feature_set::alpenglow::TEST_KEYPAIR;
+    let blockhash = client.get_latest_blockhash().unwrap();
+    let lamports = client
+        .get_minimum_balance_for_rent_exemption(solana_feature_gate_interface::Feature::size_of())
+        .unwrap();
+
+    let activation_message = solana_message::Message::new(
+        &solana_feature_gate_interface::activate_with_lamports(
+            &agave_feature_set::alpenglow::id(),
+            &faucet_keypair.pubkey(),
+            lamports,
+        ),
+        Some(&faucet_keypair.pubkey()),
+    );
+    let activation_tx = solana_transaction::Transaction::new(
+        &[&feature_keypair, &faucet_keypair],
+        activation_message,
+        blockhash,
+    );
+
+    client.send_and_confirm_transaction(&activation_tx).unwrap();
+    info!("Feature activation transaction confirmed");
+
+    // Monitor for feature activation
+    let activation_slot;
+    loop {
+        if let Ok(account) = client.get_account(&agave_feature_set::alpenglow::id()) {
+            if let Some(feature) = solana_feature_gate_interface::from_account(&account) {
+                if let Some(slot) = feature.activated_at {
+                    activation_slot = slot;
+                    info!("Feature activated at slot {slot}");
+                    break;
+                }
+            }
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+
+    // The migration happens at a fixed offset from feature activation
+    let migration_slot = activation_slot + MIGRATION_SLOT_OFFSET;
+    info!("Waiting for migration slot {migration_slot}");
+
+    loop {
+        let slot = client.get_slot().unwrap();
+        if slot >= migration_slot - 1 {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+
+    info!("Migration slot reached, checking for notarized votes");
+
+    // Check for new notarized votes
+    cluster.check_for_new_notarized_votes(
+        4,
+        test_name,
+        SocketAddrSpace::Unspecified,
+        vote_listener_addr,
+        &validator_keys,
+        &node_stakes,
+    );
+
+    // Additionally ensure that roots are being made
+    cluster.check_for_new_roots(8, test_name, SocketAddrSpace::Unspecified);
+}
+
+#[test]
+#[serial]
+fn test_alpenglow_migration_1() {
+    test_alpenglow_migration(1)
+}
+
+#[test]
+#[serial]
+fn test_alpenglow_migration_2() {
+    test_alpenglow_migration(2)
+}
+
+#[test]
+#[serial]
+fn test_alpenglow_migration_4() {
+    test_alpenglow_migration(4)
+}
+
 fn broadcast_vote(
     message: ConsensusMessage,
     tpu_socket_addrs: &[std::net::SocketAddr],

local-cluster/tests/local_cluster.rs

@@ -67,7 +67,7 @@ declare_process_instruction!(Entrypoint, DEFAULT_COMPUTE_UNITS, |invoke_context|
     }
 
     // Determine the target vote state version to use for all operations.
-    let target_version = vote_state::TEMP_HARDCODED_TARGET_VERSION;
+    let target_version = *vote_state::TEMP_HARDCODED_TARGET_VERSION.lock().unwrap();
 
     let signers = instruction_context.get_signers()?;
     match limited_deserialize(data, solana_packet::PACKET_DATA_SIZE as u64)? {

programs/vote/src/vote_processor.rs

@@ -23,11 +23,12 @@ use {
     std::{
         cmp::Ordering,
         collections::{HashSet, VecDeque},
+        sync::{LazyLock, Mutex},
     },
 };
 
-// TODO: Change me once the program has full v4 feature gate support.
-pub(crate) const TEMP_HARDCODED_TARGET_VERSION: VoteStateTargetVersion = VoteStateTargetVersion::V3;
+pub static TEMP_HARDCODED_TARGET_VERSION: LazyLock<Mutex<VoteStateTargetVersion>> =
+    LazyLock::new(|| Mutex::new(VoteStateTargetVersion::V3));
 
 // utility function, used by Stakes, tests
 pub fn from<T: ReadableAccount>(account: &T) -> Option<VoteStateV3> {

programs/vote/src/vote_state/mod.rs

@@ -44,8 +44,13 @@ use {solana_bls_signatures::Signature as BLSSignature, solana_hash::Hash};
 /// The slot offset post feature flag activation to begin the migration.
 /// Epoch boundaries induce heavy computation often resulting in forks. It's best to decouple the migration period
 /// from the boundary. We require that a root is made between the epoch boundary and this migration slot offset.
+#[cfg(not(feature = "dev-context-only-utils"))]
 pub const MIGRATION_SLOT_OFFSET: Slot = 5000;
 
+/// Small offset for tests
+#[cfg(feature = "dev-context-only-utils")]
+pub const MIGRATION_SLOT_OFFSET: Slot = 32;
+
 /// We match Alpenglow's 20 + 20 model, by allowing a maximum of 20% malicious stake during the migration.
 pub const MIGRATION_MALICIOUS_THRESHOLD: f64 = 20.0 / 100.0;