solana_loader_v3_interface/
state.rs

1use solana_pubkey::Pubkey;
2
3/// Upgradeable loader account states
4#[cfg_attr(feature = "frozen-abi", derive(solana_frozen_abi_macro::AbiExample))]
5#[cfg_attr(
6    feature = "serde",
7    derive(serde_derive::Deserialize, serde_derive::Serialize)
8)]
9#[derive(Debug, PartialEq, Eq, Clone, Copy)]
10pub enum UpgradeableLoaderState {
11    /// Account is not initialized.
12    Uninitialized,
13    /// A Buffer account.
14    Buffer {
15        /// Authority address
16        authority_address: Option<Pubkey>,
17        // The raw program data follows this serialized structure in the
18        // account's data.
19    },
20    /// An Program account.
21    Program {
22        /// Address of the ProgramData account.
23        programdata_address: Pubkey,
24    },
25    // A ProgramData account.
26    ProgramData {
27        /// Slot that the program was last modified.
28        slot: u64,
29        /// Address of the Program's upgrade authority.
30        upgrade_authority_address: Option<Pubkey>,
31        // The raw program data follows this serialized structure in the
32        // account's data.
33    },
34}
35impl UpgradeableLoaderState {
36    /// Size of a serialized program account.
37    pub const fn size_of_uninitialized() -> usize {
38        4 // see test_state_size_of_uninitialized
39    }
40
41    /// Size of a buffer account's serialized metadata.
42    pub const fn size_of_buffer_metadata() -> usize {
43        37 // see test_state_size_of_buffer_metadata
44    }
45
46    /// Size of a programdata account's serialized metadata.
47    pub const fn size_of_programdata_metadata() -> usize {
48        45 // see test_state_size_of_programdata_metadata
49    }
50
51    /// Size of a serialized program account.
52    pub const fn size_of_program() -> usize {
53        36 // see test_state_size_of_program
54    }
55
56    /// Size of a serialized buffer account.
57    pub const fn size_of_buffer(program_len: usize) -> usize {
58        Self::size_of_buffer_metadata().saturating_add(program_len)
59    }
60
61    /// Size of a serialized programdata account.
62    pub const fn size_of_programdata(program_len: usize) -> usize {
63        Self::size_of_programdata_metadata().saturating_add(program_len)
64    }
65}
66
67#[cfg(test)]
68mod tests {
69    use {super::*, bincode::serialized_size};
70
71    #[test]
72    fn test_state_size_of_uninitialized() {
73        let buffer_state = UpgradeableLoaderState::Uninitialized;
74        let size = serialized_size(&buffer_state).unwrap();
75        assert_eq!(UpgradeableLoaderState::size_of_uninitialized() as u64, size);
76    }
77
78    #[test]
79    fn test_state_size_of_buffer_metadata() {
80        let buffer_state = UpgradeableLoaderState::Buffer {
81            authority_address: Some(Pubkey::default()),
82        };
83        let size = serialized_size(&buffer_state).unwrap();
84        assert_eq!(
85            UpgradeableLoaderState::size_of_buffer_metadata() as u64,
86            size
87        );
88    }
89
90    #[test]
91    fn test_state_size_of_programdata_metadata() {
92        let programdata_state = UpgradeableLoaderState::ProgramData {
93            upgrade_authority_address: Some(Pubkey::default()),
94            slot: 0,
95        };
96        let size = serialized_size(&programdata_state).unwrap();
97        assert_eq!(
98            UpgradeableLoaderState::size_of_programdata_metadata() as u64,
99            size
100        );
101    }
102
103    #[test]
104    fn test_state_size_of_program() {
105        let program_state = UpgradeableLoaderState::Program {
106            programdata_address: Pubkey::default(),
107        };
108        let size = serialized_size(&program_state).unwrap();
109        assert_eq!(UpgradeableLoaderState::size_of_program() as u64, size);
110    }
111}