sbpf build don't like bitflags!. so implement the flags by ourself.

account-decoder/src/parse_stake.rs

@@ -136,7 +136,7 @@ impl From<Delegation> for UiDelegation {
 
 #[cfg(test)]
 mod test {
-    use {super::*, bincode::serialize, solana_sdk::stake::state::StakeFlags};
+    use {super::*, bincode::serialize, solana_sdk::stake::stake_flags::StakeFlags};
 
     #[test]
     fn test_parse_stake() {

programs/stake/src/stake_instruction.rs

@@ -510,7 +510,8 @@ mod tests {
                     set_lockup_checked, AuthorizeCheckedWithSeedArgs, AuthorizeWithSeedArgs,
                     LockupArgs, StakeError,
                 },
-                state::{Authorized, Lockup, StakeActivationStatus, StakeAuthorize, StakeFlags},
+                stake_flags::StakeFlags,
+                state::{Authorized, Lockup, StakeActivationStatus, StakeAuthorize},
                 MINIMUM_DELINQUENT_EPOCHS_FOR_DEACTIVATION,
             },
             stake_history::{StakeHistory, StakeHistoryEntry},

programs/stake/src/stake_state.rs

@@ -25,6 +25,7 @@ use {
             config::Config,
             instruction::{LockupArgs, StakeError},
             program::id,
+            stake_flags::StakeFlags,
             tools::{acceptable_reference_epoch_credits, eligible_for_deactivate_delinquent},
         },
         stake_history::{StakeHistory, StakeHistoryEntry},

runtime/src/stake_account.rs

@@ -125,7 +125,10 @@ impl AbiExample for StakeAccount<Delegation> {
     fn example() -> Self {
         use solana_sdk::{
             account::Account,
-            stake::state::{Meta, Stake, StakeFlags},
+            stake::{
+                stake_flags::StakeFlags,
+                state::{Meta, Stake},
+            },
         };
         let stake_state =
             StakeState::Stake(Meta::example(), Stake::example(), StakeFlags::example());

sdk/program/src/stake/mod.rs

@@ -4,6 +4,7 @@
 
 pub mod config;
 pub mod instruction;
+pub mod stake_flags;
 pub mod state;
 pub mod tools;
 

sdk/program/src/stake/stake_flags.rs

@@ -0,0 +1,94 @@
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+
+/// Additional flags for stake state.
+#[derive(
+    Serialize,
+    Deserialize,
+    AbiExample,
+    BorshDeserialize,
+    BorshSchema,
+    BorshSerialize,
+    Copy,
+    PartialEq,
+    Eq,
+    Clone,
+    PartialOrd,
+    Ord,
+    Hash,
+    Debug,
+)]
+pub struct StakeFlags {
+    bits: u8,
+}
+
+/// Currently, only bit 1 is used. The other 7 bits are reserved for future usage.
+impl StakeFlags {
+    ///  Stake must be fully activated before deactivation is allowed (bit 1).
+    pub const MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED: Self =
+        Self { bits: 0b0000_0001 };
+
+    pub const fn empty() -> Self {
+        Self { bits: 0 }
+    }
+
+    pub const fn contains(&self, other: Self) -> bool {
+        (self.bits & other.bits) == other.bits
+    }
+
+    pub fn remove(&mut self, other: Self) {
+        self.bits &= !other.bits;
+    }
+
+    pub fn set(&mut self, other: Self) {
+        self.bits |= other.bits;
+    }
+
+    pub const fn union(self, other: Self) -> Self {
+        Self {
+            bits: self.bits | other.bits,
+        }
+    }
+}
+
+impl Default for StakeFlags {
+    fn default() -> Self {
+        StakeFlags::empty()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_stake_flags() {
+        let mut f = StakeFlags::empty();
+        assert!(!f.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+
+        f.set(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED);
+        assert!(f.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+
+        f.remove(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED);
+        assert!(!f.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+
+        let f1 = StakeFlags::empty();
+        let f2 = StakeFlags::empty();
+        let f3 = f1.union(f2);
+        assert!(!f3.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+
+        let f1 = StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED;
+        let f2 = StakeFlags::empty();
+        let f3 = f1.union(f2);
+        assert!(f3.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+
+        let f1 = StakeFlags::empty();
+        let f2 = StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED;
+        let f3 = f1.union(f2);
+        assert!(f3.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+
+        let f1 = StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED;
+        let f2 = StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED;
+        let f3 = f1.union(f2);
+        assert!(f3.contains(StakeFlags::MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED));
+    }
+}

sdk/program/src/stake/state.rs

@@ -7,39 +7,16 @@ use {
         stake::{
             config::Config,
             instruction::{LockupArgs, StakeError},
+            stake_flags::StakeFlags,
         },
         stake_history::{StakeHistory, StakeHistoryEntry},
     },
-    bitflags::bitflags,
     borsh::{maybestd::io, BorshDeserialize, BorshSchema, BorshSerialize},
     std::collections::HashSet,
 };
 
 pub type StakeActivationStatus = StakeHistoryEntry;
 
-bitflags! {
-    #[derive(
-        Serialize,
-        Deserialize,
-        AbiExample,
-        BorshDeserialize,
-        BorshSchema,
-        BorshSerialize,
-    )]
-    // Additional flags for stake state.
-    // Currently only bit 1 is used. The other 7 bits are reserved for future.
-    pub struct StakeFlags : u8 {
-        // Stake must be fully activated before deactivation is allowed
-        const MUST_FULLY_ACTIVATE_BEFORE_DEACTIVATION_IS_PERMITTED = 0b0000_0001;
-    }
-}
-
-impl Default for StakeFlags {
-    fn default() -> Self {
-        StakeFlags::empty()
-    }
-}
-
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq, Clone, Copy, AbiExample)]
 #[allow(clippy::large_enum_variant)]
 pub enum StakeState {