solana_vote_interface/

instruction.rs

//! Vote program instructions

#[cfg(feature = "stable-abi")]
use solana_frozen_abi_macro::{frozen_abi, StableAbi, StableAbiSample};
use {
    super::state::TowerSync,
    crate::state::{
        Vote, VoteAuthorize, VoteAuthorizeCheckedWithSeedArgs, VoteAuthorizeWithSeedArgs, VoteInit,
        VoteInitV2, VoteStateUpdate, VoteStateV4,
    },
    solana_clock::{Slot, UnixTimestamp},
    solana_hash::Hash,
    solana_pubkey::Pubkey,
};
#[cfg(any(feature = "bincode", feature = "wincode"))]
use {
    crate::program::id,
    solana_instruction::{AccountMeta, Instruction},
    solana_sdk_ids::{system_program, sysvar},
};
#[cfg(feature = "wincode")]
use {
    crate::state::wincode_compact::{CompactTowerSync, CompactVoteStateUpdate},
    wincode::{SchemaRead, SchemaWrite},
};
#[cfg(feature = "serde")]
use {
    crate::state::{serde_compact_vote_state_update, serde_tower_sync},
    serde_derive::{Deserialize, Serialize},
};

#[repr(u8)]
#[cfg_attr(feature = "stable-abi", derive(StableAbi, StableAbiSample))]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
#[cfg_attr(feature = "wincode", derive(SchemaWrite, SchemaRead))]
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum CommissionKind {
    InflationRewards = 0,
    BlockRevenue = 1,
}

#[cfg_attr(
    feature = "stable-abi",
    frozen_abi(
        abi_digest = "9bqZ5L1KnMFnjQPMoRtfhdgUok3G5W2KKRGuw8uwbkuY",
        abi_serializer = ["bincode", "wincode"]
    ),
    derive(StableAbi, StableAbiSample)
)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
#[cfg_attr(feature = "wincode", derive(SchemaWrite, SchemaRead))]
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum VoteInstruction {
    /// Initialize a vote account
    ///
    /// # Account references
    ///   0. `[WRITE]` Uninitialized vote account
    ///   1. `[]` Rent sysvar
    ///   2. `[]` Clock sysvar
    ///   3. `[SIGNER]` New validator identity (node_pubkey)
    ///
    /// This instruction MUST be included within the same Transaction as the
    /// system program's `CreateAccount` instruction that creates the account
    /// being initialized. Otherwise another party can acquire ownership of the
    /// uninitialized account.
    InitializeAccount(VoteInit),

    /// Authorize a key to send votes or issue a withdrawal
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated with the Pubkey for authorization
    ///   1. `[]` Clock sysvar
    ///   2. `[SIGNER]` Vote or withdraw authority
    ///
    /// When SIMD-0387 is enabled, the `VoteAuthorize::Voter` variant is
    /// disallowed for any vote accounts whose BLS pubkey is set to `Some`.
    Authorize(Pubkey, VoteAuthorize),

    /// A Vote instruction with recent votes
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to vote with
    ///   1. `[]` Slot hashes sysvar
    ///   2. `[]` Clock sysvar
    ///   3. `[SIGNER]` Vote authority
    Vote(Vote),

    /// Withdraw some amount of funds
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to withdraw from
    ///   1. `[WRITE]` Recipient account
    ///   2. `[SIGNER]` Withdraw authority
    Withdraw(u64),

    /// Update the vote account's validator identity (node_pubkey)
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated with the given authority public key
    ///   1. `[SIGNER]` New validator identity (node_pubkey)
    ///   2. `[SIGNER]` Withdraw authority
    UpdateValidatorIdentity,

    /// Update the commission for the vote account
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated
    ///   1. `[SIGNER]` Withdraw authority
    UpdateCommission(u8),

    /// A Vote instruction with recent votes
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to vote with
    ///   1. `[]` Slot hashes sysvar
    ///   2. `[]` Clock sysvar
    ///   3. `[SIGNER]` Vote authority
    VoteSwitch(Vote, Hash),

    /// Authorize a key to send votes or issue a withdrawal
    ///
    /// This instruction behaves like `Authorize` with the additional requirement that the new vote
    /// or withdraw authority must also be a signer.
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated with the Pubkey for authorization
    ///   1. `[]` Clock sysvar
    ///   2. `[SIGNER]` Vote or withdraw authority
    ///   3. `[SIGNER]` New vote or withdraw authority
    ///
    /// When SIMD-0387 is enabled, the `VoteAuthorize::Voter` variant is
    /// disallowed for any vote accounts whose BLS pubkey is set to `Some`.
    AuthorizeChecked(VoteAuthorize),

    /// Update the onchain vote state for the signer.
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to vote with
    ///   1. `[SIGNER]` Vote authority
    UpdateVoteState(VoteStateUpdate),

    /// Update the onchain vote state for the signer along with a switching proof.
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to vote with
    ///   1. `[SIGNER]` Vote authority
    UpdateVoteStateSwitch(VoteStateUpdate, Hash),

    /// Given that the current Voter or Withdrawer authority is a derived key,
    /// this instruction allows someone who can sign for that derived key's
    /// base key to authorize a new Voter or Withdrawer for a vote account.
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to be updated
    ///   1. `[]` Clock sysvar
    ///   2. `[SIGNER]` Base key of current Voter or Withdrawer authority's derived key
    ///
    /// When SIMD-0387 is enabled, the `VoteAuthorize::Voter` variant in
    /// `authorization_type` is disallowed for any vote accounts whose BLS
    /// pubkey is set to `Some`.
    AuthorizeWithSeed(VoteAuthorizeWithSeedArgs),

    /// Given that the current Voter or Withdrawer authority is a derived key,
    /// this instruction allows someone who can sign for that derived key's
    /// base key to authorize a new Voter or Withdrawer for a vote account.
    ///
    /// This instruction behaves like `AuthorizeWithSeed` with the additional requirement
    /// that the new vote or withdraw authority must also be a signer.
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to be updated
    ///   1. `[]` Clock sysvar
    ///   2. `[SIGNER]` Base key of current Voter or Withdrawer authority's derived key
    ///   3. `[SIGNER]` New vote or withdraw authority
    ///
    /// When SIMD-0387 is enabled, the `VoteAuthorize::Voter` variant in
    /// `authorization_type` is disallowed for any vote accounts whose BLS
    /// pubkey is set to `Some`.
    AuthorizeCheckedWithSeed(VoteAuthorizeCheckedWithSeedArgs),

    /// Update the onchain vote state for the signer.
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to vote with
    ///   1. `[SIGNER]` Vote authority
    #[cfg_attr(feature = "serde", serde(with = "serde_compact_vote_state_update"))]
    CompactUpdateVoteState(
        #[cfg_attr(feature = "wincode", wincode(with = "CompactVoteStateUpdate"))] VoteStateUpdate,
    ),

    /// Update the onchain vote state for the signer along with a switching proof.
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to vote with
    ///   1. `[SIGNER]` Vote authority
    CompactUpdateVoteStateSwitch(
        #[cfg_attr(feature = "serde", serde(with = "serde_compact_vote_state_update"))]
        #[cfg_attr(feature = "wincode", wincode(with = "CompactVoteStateUpdate"))]
        VoteStateUpdate,
        Hash,
    ),

    /// Sync the onchain vote state with local tower
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to vote with
    ///   1. `[SIGNER]` Vote authority
    #[cfg_attr(feature = "serde", serde(with = "serde_tower_sync"))]
    TowerSync(#[cfg_attr(feature = "wincode", wincode(with = "CompactTowerSync"))] TowerSync),

    /// Sync the onchain vote state with local tower along with a switching proof
    ///
    /// # Account references
    ///   0. `[Write]` Vote account to vote with
    ///   1. `[SIGNER]` Vote authority
    TowerSyncSwitch(
        #[cfg_attr(feature = "serde", serde(with = "serde_tower_sync"))]
        #[cfg_attr(feature = "wincode", wincode(with = "CompactTowerSync"))]
        TowerSync,
        Hash,
    ),

    /// Initialize a vote account with all vote state v4 fields, including
    /// BLS public key and collector accounts.
    ///
    /// The vote program performs BLS proof-of-possession verification on the
    /// submitted BLS public key (per SIMD-0387). For each collector account
    /// (indices 2 and 3), the program performs the same validation as
    /// `UpdateCommissionCollector` (per SIMD-0232): if the collector is not
    /// the vote account itself, it must be system-program owned, rent-exempt,
    /// and writable (not a reserved account).
    ///
    /// # Account references
    ///   0. `[WRITE]` Uninitialized vote account
    ///   1. `[SIGNER]` New validator identity (node_pubkey)
    ///   2. `[WRITE]` Inflation rewards collector
    ///   3. `[WRITE]` Block revenue collector
    ///
    /// This instruction MUST be included within the same Transaction as the
    /// system program's `CreateAccount` instruction that creates the account
    /// being initialized. Otherwise another party can acquire ownership of the
    /// uninitialized account.
    InitializeAccountV2(VoteInitV2),

    /// Update the commission collector for the vote account
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated with the new collector public key
    ///   1. `[WRITE]` New collector account. Must be set to the vote account or
    ///      a system program owned account. Must be writable to ensure the
    ///      account is not reserved.
    ///   2. `[SIGNER]` Vote account withdraw authority
    UpdateCommissionCollector(CommissionKind),

    /// Update the commission rate in basis points for the specified commission
    /// rate kind in a vote account.
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated with the new commission
    ///   1. `[SIGNER]` Vote account withdraw authority
    UpdateCommissionBps {
        commission_bps: u16,
        kind: CommissionKind,
    },

    /// Deposit lamports for distribution to stake delegators
    ///
    /// # Account references
    ///   0. `[WRITE]` Vote account to be updated with the deposit
    ///   1. `[SIGNER, WRITE]` Source account for deposit funds
    ///   2. `[]` System program, used to transfer the deposit
    DepositDelegatorRewards { deposit: u64 },
}

impl VoteInstruction {
    pub fn is_simple_vote(&self) -> bool {
        matches!(
            self,
            Self::Vote(_)
                | Self::VoteSwitch(_, _)
                | Self::UpdateVoteState(_)
                | Self::UpdateVoteStateSwitch(_, _)
                | Self::CompactUpdateVoteState(_)
                | Self::CompactUpdateVoteStateSwitch(_, _)
                | Self::TowerSync(_)
                | Self::TowerSyncSwitch(_, _),
        )
    }

    pub fn is_single_vote_state_update(&self) -> bool {
        matches!(
            self,
            Self::UpdateVoteState(_)
                | Self::UpdateVoteStateSwitch(_, _)
                | Self::CompactUpdateVoteState(_)
                | Self::CompactUpdateVoteStateSwitch(_, _)
                | Self::TowerSync(_)
                | Self::TowerSyncSwitch(_, _),
        )
    }

    /// Only to be used on vote instructions (guard with is_simple_vote),  panics otherwise
    pub fn last_voted_slot(&self) -> Option<Slot> {
        assert!(self.is_simple_vote());
        match self {
            Self::Vote(v) | Self::VoteSwitch(v, _) => v.last_voted_slot(),
            Self::UpdateVoteState(vote_state_update)
            | Self::UpdateVoteStateSwitch(vote_state_update, _)
            | Self::CompactUpdateVoteState(vote_state_update)
            | Self::CompactUpdateVoteStateSwitch(vote_state_update, _) => {
                vote_state_update.last_voted_slot()
            }
            Self::TowerSync(tower_sync) | Self::TowerSyncSwitch(tower_sync, _) => {
                tower_sync.last_voted_slot()
            }
            _ => panic!("Tried to get slot on non simple vote instruction"),
        }
    }

    /// Only to be used on vote instructions (guard with is_simple_vote), panics otherwise
    pub fn hash(&self) -> Hash {
        assert!(self.is_simple_vote());
        let hash = match self {
            Self::Vote(v) | Self::VoteSwitch(v, _) => &v.hash,
            Self::UpdateVoteState(vote_state_update)
            | Self::UpdateVoteStateSwitch(vote_state_update, _)
            | Self::CompactUpdateVoteState(vote_state_update)
            | Self::CompactUpdateVoteStateSwitch(vote_state_update, _) => &vote_state_update.hash,
            Self::TowerSync(tower_sync) | Self::TowerSyncSwitch(tower_sync, _) => &tower_sync.hash,
            _ => panic!("Tried to get hash on non simple vote instruction"),
        };
        Hash::new_from_array(hash.to_bytes())
    }
    /// Only to be used on vote instructions (guard with is_simple_vote),  panics otherwise
    pub fn timestamp(&self) -> Option<UnixTimestamp> {
        assert!(self.is_simple_vote());
        match self {
            Self::Vote(v) | Self::VoteSwitch(v, _) => v.timestamp,
            Self::UpdateVoteState(vote_state_update)
            | Self::UpdateVoteStateSwitch(vote_state_update, _)
            | Self::CompactUpdateVoteState(vote_state_update)
            | Self::CompactUpdateVoteStateSwitch(vote_state_update, _) => {
                vote_state_update.timestamp
            }
            Self::TowerSync(tower_sync) | Self::TowerSyncSwitch(tower_sync, _) => {
                tower_sync.timestamp
            }
            _ => panic!("Tried to get timestamp on non simple vote instruction"),
        }
    }
}

#[cfg(all(feature = "bincode", not(feature = "wincode")))]
#[inline(always)]
fn create_instruction(
    program_id: Pubkey,
    data: &VoteInstruction,
    accounts: Vec<AccountMeta>,
) -> Instruction {
    Instruction::new_with_bincode(program_id, data, accounts)
}

#[cfg(feature = "wincode")]
#[inline(always)]
fn create_instruction(
    program_id: Pubkey,
    data: &VoteInstruction,
    accounts: Vec<AccountMeta>,
) -> Instruction {
    Instruction::new_with_wincode(program_id, data, accounts)
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
fn initialize_account(vote_pubkey: &Pubkey, vote_init: &VoteInit) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::rent::id(), false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(vote_init.node_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::InitializeAccount(*vote_init),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
fn initialize_account_v2(
    vote_pubkey: &Pubkey,
    vote_init: &VoteInitV2,
    inflation_rewards_collector: &Pubkey,
    block_revenue_collector: &Pubkey,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(vote_init.node_pubkey, true),
        AccountMeta::new(*inflation_rewards_collector, false),
        AccountMeta::new(*block_revenue_collector, false),
    ];

    create_instruction(
        id(),
        &VoteInstruction::InitializeAccountV2(*vote_init),
        account_metas,
    )
}

pub struct CreateVoteAccountConfig<'a> {
    pub space: u64,
    pub with_seed: Option<(&'a Pubkey, &'a str)>,
}

impl Default for CreateVoteAccountConfig<'_> {
    fn default() -> Self {
        Self {
            // Create new vote accounts with size for V4.
            space: VoteStateV4::size_of() as u64,
            with_seed: None,
        }
    }
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn create_account_with_config(
    from_pubkey: &Pubkey,
    vote_pubkey: &Pubkey,
    vote_init: &VoteInit,
    lamports: u64,
    config: CreateVoteAccountConfig,
) -> Vec<Instruction> {
    let create_ix = if let Some((base, seed)) = config.with_seed {
        solana_system_interface::instruction::create_account_with_seed(
            from_pubkey,
            vote_pubkey,
            base,
            seed,
            lamports,
            config.space,
            &id(),
        )
    } else {
        solana_system_interface::instruction::create_account(
            from_pubkey,
            vote_pubkey,
            lamports,
            config.space,
            &id(),
        )
    };
    let init_ix = initialize_account(vote_pubkey, vote_init);
    vec![create_ix, init_ix]
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn create_account_with_config_v2(
    from_pubkey: &Pubkey,
    vote_pubkey: &Pubkey,
    vote_init: &VoteInitV2,
    inflation_rewards_collector: &Pubkey,
    block_revenue_collector: &Pubkey,
    lamports: u64,
    config: CreateVoteAccountConfig,
) -> Vec<Instruction> {
    let create_ix = if let Some((base, seed)) = config.with_seed {
        solana_system_interface::instruction::create_account_with_seed(
            from_pubkey,
            vote_pubkey,
            base,
            seed,
            lamports,
            config.space,
            &id(),
        )
    } else {
        solana_system_interface::instruction::create_account(
            from_pubkey,
            vote_pubkey,
            lamports,
            config.space,
            &id(),
        )
    };
    let init_ix = initialize_account_v2(
        vote_pubkey,
        vote_init,
        inflation_rewards_collector,
        block_revenue_collector,
    );
    vec![create_ix, init_ix]
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn authorize(
    vote_pubkey: &Pubkey,
    authorized_pubkey: &Pubkey, // currently authorized
    new_authorized_pubkey: &Pubkey,
    vote_authorize: VoteAuthorize,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(*authorized_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::Authorize(*new_authorized_pubkey, vote_authorize),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn authorize_checked(
    vote_pubkey: &Pubkey,
    authorized_pubkey: &Pubkey, // currently authorized
    new_authorized_pubkey: &Pubkey,
    vote_authorize: VoteAuthorize,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(*authorized_pubkey, true),
        AccountMeta::new_readonly(*new_authorized_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::AuthorizeChecked(vote_authorize),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn authorize_with_seed(
    vote_pubkey: &Pubkey,
    current_authority_base_key: &Pubkey,
    current_authority_derived_key_owner: &Pubkey,
    current_authority_derived_key_seed: &str,
    new_authority: &Pubkey,
    authorization_type: VoteAuthorize,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(*current_authority_base_key, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::AuthorizeWithSeed(VoteAuthorizeWithSeedArgs {
            authorization_type,
            current_authority_derived_key_owner: *current_authority_derived_key_owner,
            current_authority_derived_key_seed: current_authority_derived_key_seed.to_string(),
            new_authority: *new_authority,
        }),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn authorize_checked_with_seed(
    vote_pubkey: &Pubkey,
    current_authority_base_key: &Pubkey,
    current_authority_derived_key_owner: &Pubkey,
    current_authority_derived_key_seed: &str,
    new_authority: &Pubkey,
    authorization_type: VoteAuthorize,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(*current_authority_base_key, true),
        AccountMeta::new_readonly(*new_authority, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::AuthorizeCheckedWithSeed(VoteAuthorizeCheckedWithSeedArgs {
            authorization_type,
            current_authority_derived_key_owner: *current_authority_derived_key_owner,
            current_authority_derived_key_seed: current_authority_derived_key_seed.to_string(),
        }),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn update_validator_identity(
    vote_pubkey: &Pubkey,
    authorized_withdrawer_pubkey: &Pubkey,
    node_pubkey: &Pubkey,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*node_pubkey, true),
        AccountMeta::new_readonly(*authorized_withdrawer_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::UpdateValidatorIdentity,
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn update_commission(
    vote_pubkey: &Pubkey,
    authorized_withdrawer_pubkey: &Pubkey,
    commission: u8,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_withdrawer_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::UpdateCommission(commission),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn update_commission_collector(
    vote_pubkey: &Pubkey,
    authorized_withdrawer_pubkey: &Pubkey,
    new_collector_pubkey: &Pubkey,
    kind: CommissionKind,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new(*new_collector_pubkey, false),
        AccountMeta::new_readonly(*authorized_withdrawer_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::UpdateCommissionCollector(kind),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn update_commission_bps(
    vote_pubkey: &Pubkey,
    authorized_withdrawer_pubkey: &Pubkey,
    kind: CommissionKind,
    commission_bps: u16,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_withdrawer_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::UpdateCommissionBps {
            kind,
            commission_bps,
        },
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn deposit_delegator_rewards(
    vote_pubkey: &Pubkey,
    source_pubkey: &Pubkey,
    deposit: u64,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new(*source_pubkey, true),
        AccountMeta::new_readonly(system_program::id(), false),
    ];

    create_instruction(
        id(),
        &VoteInstruction::DepositDelegatorRewards { deposit },
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn vote(vote_pubkey: &Pubkey, authorized_voter_pubkey: &Pubkey, vote: Vote) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::slot_hashes::id(), false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(id(), &VoteInstruction::Vote(vote), account_metas)
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn vote_switch(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    vote: Vote,
    proof_hash: Hash,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(sysvar::slot_hashes::id(), false),
        AccountMeta::new_readonly(sysvar::clock::id(), false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::VoteSwitch(vote, proof_hash),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn update_vote_state(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    vote_state_update: VoteStateUpdate,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::UpdateVoteState(vote_state_update),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn update_vote_state_switch(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    vote_state_update: VoteStateUpdate,
    proof_hash: Hash,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::UpdateVoteStateSwitch(vote_state_update, proof_hash),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn compact_update_vote_state(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    vote_state_update: VoteStateUpdate,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::CompactUpdateVoteState(vote_state_update),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn compact_update_vote_state_switch(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    vote_state_update: VoteStateUpdate,
    proof_hash: Hash,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::CompactUpdateVoteStateSwitch(vote_state_update, proof_hash),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn tower_sync(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    tower_sync: TowerSync,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(id(), &VoteInstruction::TowerSync(tower_sync), account_metas)
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn tower_sync_switch(
    vote_pubkey: &Pubkey,
    authorized_voter_pubkey: &Pubkey,
    tower_sync: TowerSync,
    proof_hash: Hash,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new_readonly(*authorized_voter_pubkey, true),
    ];

    create_instruction(
        id(),
        &VoteInstruction::TowerSyncSwitch(tower_sync, proof_hash),
        account_metas,
    )
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn withdraw(
    vote_pubkey: &Pubkey,
    authorized_withdrawer_pubkey: &Pubkey,
    lamports: u64,
    to_pubkey: &Pubkey,
) -> Instruction {
    let account_metas = vec![
        AccountMeta::new(*vote_pubkey, false),
        AccountMeta::new(*to_pubkey, false),
        AccountMeta::new_readonly(*authorized_withdrawer_pubkey, true),
    ];

    create_instruction(id(), &VoteInstruction::Withdraw(lamports), account_metas)
}

#[cfg(all(test, feature = "bincode"))]
mod tests {
    use {super::*, crate::state::Lockout, std::collections::VecDeque};

    #[test]
    fn test_compact_serialize_rejects_confirmation_count_above_u8() {
        // The compact wire format stores `confirmation_count` as a `u8`, so a
        // value that does not fit (> 255) must fail to serialize rather than be
        // silently truncated.
        let lockouts = VecDeque::from([Lockout::new_with_confirmation_count(1, 256)]);
        let vote_state_update = VoteStateUpdate::new(lockouts.clone(), None, Hash::default());
        let tower_sync = TowerSync::new(lockouts, None, Hash::default(), Hash::default());

        for ix in [
            VoteInstruction::CompactUpdateVoteState(vote_state_update),
            VoteInstruction::TowerSync(tower_sync),
        ] {
            let err = bincode::serialize(&ix).unwrap_err();
            assert!(
                err.to_string().contains("Invalid confirmation count"),
                "unexpected error: {err}"
            );
            #[cfg(feature = "wincode")]
            assert!(wincode::serialize(&ix).is_err());
        }
    }

    #[test]
    fn test_deposit_delegator_rewards_includes_system_program() {
        let vote_pubkey = Pubkey::new_unique();
        let source_pubkey = Pubkey::new_unique();

        let instruction = deposit_delegator_rewards(&vote_pubkey, &source_pubkey, 100_000);

        assert_eq!(instruction.program_id, id());
        assert_eq!(instruction.accounts.len(), 3);

        let vote_meta = &instruction.accounts[0];
        assert_eq!(vote_meta.pubkey, vote_pubkey);
        assert!(!vote_meta.is_signer);
        assert!(vote_meta.is_writable);

        let source_meta = &instruction.accounts[1];
        assert_eq!(source_meta.pubkey, source_pubkey);
        assert!(source_meta.is_signer);
        assert!(source_meta.is_writable);

        // The vote program transfers the deposit by invoking the System program,
        // which the runtime only resolves if it is one of the instruction's accounts.
        let system_program_meta = &instruction.accounts[2];
        assert_eq!(system_program_meta.pubkey, system_program::id());
        assert!(!system_program_meta.is_signer);
        assert!(!system_program_meta.is_writable);
    }

    #[test]
    fn test_builders_match_bincode_encoding() {
        let vote_pubkey = Pubkey::new_unique();
        let voter_pubkey = Pubkey::new_unique();
        let lockouts = VecDeque::from([Lockout::new_with_confirmation_count(1, 2)]);
        let tower_sync = TowerSync::new(
            lockouts,
            Some(0),
            Hash::new_from_array([1; 32]),
            Hash::new_from_array([2; 32]),
        );
        let vote_init = VoteInit {
            node_pubkey: Pubkey::new_unique(),
            authorized_voter: voter_pubkey,
            authorized_withdrawer: Pubkey::new_unique(),
            commission: 7,
        };

        for (ix, expected) in [
            (
                tower_sync_switch(
                    &vote_pubkey,
                    &voter_pubkey,
                    tower_sync.clone(),
                    Hash::default(),
                ),
                VoteInstruction::TowerSyncSwitch(tower_sync, Hash::default()),
            ),
            (
                authorize_with_seed(
                    &vote_pubkey,
                    &voter_pubkey,
                    &vote_pubkey,
                    "seed",
                    &voter_pubkey,
                    VoteAuthorize::Withdrawer,
                ),
                VoteInstruction::AuthorizeWithSeed(VoteAuthorizeWithSeedArgs {
                    authorization_type: VoteAuthorize::Withdrawer,
                    current_authority_derived_key_owner: vote_pubkey,
                    current_authority_derived_key_seed: "seed".to_string(),
                    new_authority: voter_pubkey,
                }),
            ),
            (
                create_account_with_config(
                    &voter_pubkey,
                    &vote_pubkey,
                    &vote_init,
                    42,
                    CreateVoteAccountConfig::default(),
                )
                .pop()
                .unwrap(),
                VoteInstruction::InitializeAccount(vote_init),
            ),
        ] {
            assert_eq!(ix.data, bincode::serialize(&expected).unwrap());
        }
    }
}