solana_loader_v3_interface/
state.rs1use solana_pubkey::Pubkey;
2
3#[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 Uninitialized,
13 Buffer {
15 authority_address: Option<Pubkey>,
17 },
20 Program {
22 programdata_address: Pubkey,
24 },
25 ProgramData {
27 slot: u64,
29 upgrade_authority_address: Option<Pubkey>,
31 },
34}
35impl UpgradeableLoaderState {
36 pub const fn size_of_uninitialized() -> usize {
38 4 }
40
41 pub const fn size_of_buffer_metadata() -> usize {
43 37 }
45
46 pub const fn size_of_programdata_metadata() -> usize {
48 45 }
50
51 pub const fn size_of_program() -> usize {
53 36 }
55
56 pub const fn size_of_buffer(program_len: usize) -> usize {
58 Self::size_of_buffer_metadata().saturating_add(program_len)
59 }
60
61 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}