diff --git a/Cargo.lock b/Cargo.lock
index a525b81c5..61116ec60 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2787,7 +2787,7 @@ dependencies = [
  "ed25519-dalek",
  "hex",
  "rand 0.7.3",
- "solana-feature-set",
+ "solana-feature-set-interface",
  "solana-hash",
  "solana-instruction",
  "solana-keypair",
@@ -3329,7 +3329,7 @@ version = "2.2.1"
 dependencies = [
  "lazy_static",
  "solana-ed25519-program",
- "solana-feature-set",
+ "solana-feature-set-interface",
  "solana-message",
  "solana-precompile-error",
  "solana-pubkey",
@@ -3615,6 +3615,7 @@ dependencies = [
  "solana-epoch-info",
  "solana-epoch-rewards-hasher",
  "solana-feature-set",
+ "solana-feature-set-interface",
  "solana-fee-structure",
  "solana-genesis-config",
  "solana-hard-forks",
@@ -3694,7 +3695,7 @@ dependencies = [
  "serde_derive",
  "sha3",
  "solana-account-info",
- "solana-feature-set",
+ "solana-feature-set-interface",
  "solana-hash",
  "solana-instruction",
  "solana-instructions-sysvar",
@@ -3730,7 +3731,7 @@ version = "2.2.1"
 dependencies = [
  "bytemuck",
  "openssl",
- "solana-feature-set",
+ "solana-feature-set-interface",
  "solana-instruction",
  "solana-logger",
  "solana-precompile-error",
@@ -3998,7 +3999,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "solana-bincode",
- "solana-feature-set",
+ "solana-feature-set-interface",
  "solana-frozen-abi",
  "solana-frozen-abi-macro",
  "solana-hash",
diff --git a/ed25519-program/Cargo.toml b/ed25519-program/Cargo.toml
index b1506086e..81197c33d 100644
--- a/ed25519-program/Cargo.toml
+++ b/ed25519-program/Cargo.toml
@@ -13,7 +13,7 @@ edition = { workspace = true }
 bytemuck = { workspace = true }
 bytemuck_derive = { workspace = true }
 ed25519-dalek = { workspace = true }
-solana-feature-set = { workspace = true }
+solana-feature-set-interface = { workspace = true }
 solana-instruction = { workspace = true, features = ["std"] }
 solana-precompile-error = { workspace = true }
 solana-sdk-ids = { workspace = true }
diff --git a/ed25519-program/src/lib.rs b/ed25519-program/src/lib.rs
index fccd50b20..287e092ca 100644
--- a/ed25519-program/src/lib.rs
+++ b/ed25519-program/src/lib.rs
@@ -6,7 +6,7 @@ use {
     bytemuck::bytes_of,
     bytemuck_derive::{Pod, Zeroable},
     ed25519_dalek::{ed25519::signature::Signature, Signer, Verifier},
-    solana_feature_set::{ed25519_precompile_verify_strict, FeatureSet},
+    solana_feature_set_interface::PrecompileFeatureSet,
     solana_instruction::Instruction,
     solana_precompile_error::PrecompileError,
 };
@@ -115,7 +115,7 @@ pub fn new_ed25519_instruction(keypair: &ed25519_dalek::Keypair, message: &[u8])
 pub fn verify(
     data: &[u8],
     instruction_datas: &[&[u8]],
-    feature_set: &FeatureSet,
+    feature_set: &PrecompileFeatureSet,
 ) -> Result<(), PrecompileError> {
     if data.len() < SIGNATURE_OFFSETS_START {
         return Err(PrecompileError::InvalidInstructionDataSize);
@@ -174,7 +174,7 @@ pub fn verify(
             offsets.message_data_size as usize,
         )?;
 
-        if feature_set.is_active(&ed25519_precompile_verify_strict::id()) {
+        if feature_set.ed25519_precompile_verify_strict_feature_enabled {
             publickey
                 .verify_strict(message, &signature)
                 .map_err(|_| PrecompileError::InvalidSignature)?;
@@ -220,7 +220,7 @@ pub mod test {
         ed25519_dalek::Signer as EdSigner,
         hex,
         rand0_7::{thread_rng, Rng},
-        solana_feature_set::FeatureSet,
+        solana_feature_set_interface::PrecompileFeatureSet,
         solana_hash::Hash,
         solana_keypair::Keypair,
         solana_sdk::transaction::Transaction,
@@ -297,7 +297,7 @@ pub mod test {
         verify(
             &instruction_data,
             &[&[0u8; 100]],
-            &FeatureSet::all_enabled(),
+            &PrecompileFeatureSet::all_enabled(),
         )
     }
 
@@ -315,7 +315,7 @@ pub mod test {
             verify(
                 &instruction_data,
                 &[&[0u8; 100]],
-                &FeatureSet::all_enabled(),
+                &PrecompileFeatureSet::all_enabled(),
             ),
             Err(PrecompileError::InvalidInstructionDataSize)
         );
@@ -441,7 +441,7 @@ pub mod test {
         let message_arr = b"hello";
         let mut instruction = new_ed25519_instruction(&privkey, message_arr);
         let mint_keypair = Keypair::new();
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
 
         let tx = Transaction::new_signed_with_payer(
             &[instruction.clone()],
@@ -512,7 +512,7 @@ pub mod test {
         }
 
         let mint_keypair = Keypair::new();
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
 
         let tx = Transaction::new_signed_with_payer(
             &[instruction.clone()],
@@ -557,10 +557,10 @@ pub mod test {
             Hash::default(),
         );
 
-        let feature_set = FeatureSet::default();
+        let feature_set = PrecompileFeatureSet::default();
         assert!(tx.verify_precompiles(&feature_set).is_ok());
 
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
         assert!(tx.verify_precompiles(&feature_set).is_ok());
 
         // malleable sig: verify_strict does NOT pass
@@ -580,10 +580,10 @@ pub mod test {
             Hash::default(),
         );
 
-        let feature_set = FeatureSet::default();
+        let feature_set = PrecompileFeatureSet::default();
         assert!(tx.verify_precompiles(&feature_set).is_ok());
 
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
         assert!(tx.verify_precompiles(&feature_set).is_err()); // verify_strict does NOT pass
     }
 }
diff --git a/feature-set-interface/src/lib.rs b/feature-set-interface/src/lib.rs
index ac742b704..ab5890531 100644
--- a/feature-set-interface/src/lib.rs
+++ b/feature-set-interface/src/lib.rs
@@ -35,6 +35,22 @@ impl FeatureSet {
     }
 }
 
+#[doc(hidden)]
+#[derive(Default)]
+pub struct PrecompileFeatureSet {
+    pub secp256r1_precompile_enabled: bool,
+    pub ed25519_precompile_verify_strict_feature_enabled: bool,
+}
+
+impl PrecompileFeatureSet {
+    pub fn all_enabled() -> Self {
+        Self {
+            secp256r1_precompile_enabled: true,
+            ed25519_precompile_verify_strict_feature_enabled: true,
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/precompiles/Cargo.toml b/precompiles/Cargo.toml
index acd533ae6..273889ad8 100644
--- a/precompiles/Cargo.toml
+++ b/precompiles/Cargo.toml
@@ -12,7 +12,7 @@ edition = { workspace = true }
 [dependencies]
 lazy_static = { workspace = true }
 solana-ed25519-program = { workspace = true }
-solana-feature-set = { workspace = true }
+solana-feature-set-interface = { workspace = true }
 solana-message = { workspace = true }
 solana-precompile-error = { workspace = true }
 solana-pubkey = { workspace = true }
diff --git a/precompiles/src/lib.rs b/precompiles/src/lib.rs
index 8ca16951e..b0c21807f 100644
--- a/precompiles/src/lib.rs
+++ b/precompiles/src/lib.rs
@@ -1,46 +1,45 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 use {
-    lazy_static::lazy_static, solana_feature_set::FeatureSet,
+    lazy_static::lazy_static, solana_feature_set_interface::PrecompileFeatureSet,
     solana_message::compiled_instruction::CompiledInstruction,
     solana_precompile_error::PrecompileError, solana_pubkey::Pubkey,
 };
 
 /// All precompiled programs must implement the `Verify` function
-pub type Verify = fn(&[u8], &[&[u8]], &FeatureSet) -> std::result::Result<(), PrecompileError>;
+pub type Verify =
+    fn(&[u8], &[&[u8]], &PrecompileFeatureSet) -> std::result::Result<(), PrecompileError>;
+
+/// All precompiled programs must implement the `Enabled` function
+pub type Enabled = fn(&PrecompileFeatureSet) -> bool;
 
 /// Information on a precompiled program
 pub struct Precompile {
     /// Program id
     pub program_id: Pubkey,
-    /// Feature to enable on, `None` indicates always enabled
-    pub feature: Option<Pubkey>,
+    /// Enabled function
+    pub enabled_fn: Enabled,
     /// Verification function
     pub verify_fn: Verify,
 }
 impl Precompile {
     /// Creates a new `Precompile`
-    pub fn new(program_id: Pubkey, feature: Option<Pubkey>, verify_fn: Verify) -> Self {
+    pub fn new(program_id: Pubkey, enabled_fn: Enabled, verify_fn: Verify) -> Self {
         Precompile {
             program_id,
-            feature,
+            enabled_fn,
             verify_fn,
         }
     }
-    /// Check if a program id is this precompiled program
-    pub fn check_id<F>(&self, program_id: &Pubkey, is_enabled: F) -> bool
-    where
-        F: Fn(&Pubkey) -> bool,
-    {
-        self.feature
-            .map_or(true, |ref feature_id| is_enabled(feature_id))
-            && self.program_id == *program_id
+    /// Check if this precompiled program is enabled
+    pub fn enabled(&self, feature_set: &PrecompileFeatureSet) -> bool {
+        (self.enabled_fn)(feature_set)
     }
     /// Verify this precompiled program
     pub fn verify(
         &self,
         data: &[u8],
         instruction_datas: &[&[u8]],
-        feature_set: &FeatureSet,
+        feature_set: &PrecompileFeatureSet,
     ) -> std::result::Result<(), PrecompileError> {
         (self.verify_fn)(data, instruction_datas, feature_set)
     }
@@ -51,40 +50,43 @@ lazy_static! {
     static ref PRECOMPILES: Vec<Precompile> = vec![
         Precompile::new(
             solana_sdk_ids::secp256k1_program::id(),
-            None, // always enabled
+            |_| true, // always enabled
             solana_secp256k1_program::verify,
         ),
         Precompile::new(
             solana_sdk_ids::ed25519_program::id(),
-            None, // always enabled
+            |_| true, // always enabled
             solana_ed25519_program::verify,
         ),
         Precompile::new(
             solana_sdk_ids::secp256r1_program::id(),
-            Some(solana_feature_set::enable_secp256r1_precompile::id()),
+            |feature_set| feature_set.secp256r1_precompile_enabled,
             solana_secp256r1_program::verify,
         )
     ];
 }
 
 /// Check if a program is a precompiled program
-pub fn is_precompile<F>(program_id: &Pubkey, is_enabled: F) -> bool
+pub fn is_precompile<F>(program_id: &Pubkey, feature_set: &PrecompileFeatureSet) -> bool
 where
     F: Fn(&Pubkey) -> bool,
 {
     PRECOMPILES
         .iter()
-        .any(|precompile| precompile.check_id(program_id, |feature_id| is_enabled(feature_id)))
+        .any(|precompile| &precompile.program_id == program_id && precompile.enabled(feature_set))
 }
 
 /// Find an enabled precompiled program
-pub fn get_precompile<F>(program_id: &Pubkey, is_enabled: F) -> Option<&Precompile>
+pub fn get_precompile<'a, F>(
+    program_id: &'a Pubkey,
+    feature_set: &PrecompileFeatureSet,
+) -> Option<&'a Precompile>
 where
     F: Fn(&Pubkey) -> bool,
 {
     PRECOMPILES
         .iter()
-        .find(|precompile| precompile.check_id(program_id, |feature_id| is_enabled(feature_id)))
+        .find(|precompile| &precompile.program_id == program_id && precompile.enabled(feature_set))
 }
 
 pub fn get_precompiles<'a>() -> &'a [Precompile] {
@@ -96,10 +98,10 @@ pub fn verify_if_precompile(
     program_id: &Pubkey,
     precompile_instruction: &CompiledInstruction,
     all_instructions: &[CompiledInstruction],
-    feature_set: &FeatureSet,
+    feature_set: &PrecompileFeatureSet,
 ) -> Result<(), PrecompileError> {
     for precompile in PRECOMPILES.iter() {
-        if precompile.check_id(program_id, |feature_id| feature_set.is_active(feature_id)) {
+        if &precompile.program_id == program_id && precompile.enabled(feature_set) {
             let instruction_datas: Vec<_> = all_instructions
                 .iter()
                 .map(|instruction| instruction.data.as_ref())
diff --git a/sdk/Cargo.toml b/sdk/Cargo.toml
index 789882edf..2603cbd6b 100644
--- a/sdk/Cargo.toml
+++ b/sdk/Cargo.toml
@@ -184,6 +184,7 @@ openssl = { workspace = true }
 rand0-7 = { workspace = true }
 serde_derive = { workspace = true }
 serde_with = { workspace = true, features = ["macros"] }
+solana-feature-set-interface = { workspace = true }
 solana-instructions-sysvar = { workspace = true, features = ["dev-context-only-utils"] }
 solana-program = { workspace = true, features = ["dev-context-only-utils"] }
 solana-sdk = { path = ".", features = ["dev-context-only-utils"] }
diff --git a/sdk/benches/ed25519_instructions.rs b/sdk/benches/ed25519_instructions.rs
index 0bd727335..1cb9a2890 100644
--- a/sdk/benches/ed25519_instructions.rs
+++ b/sdk/benches/ed25519_instructions.rs
@@ -3,7 +3,7 @@
 extern crate test;
 use {
     rand0_7::{thread_rng, Rng},
-    solana_feature_set::FeatureSet,
+    solana_feature_set_interface::PrecompileFeatureSet,
     solana_sdk::{
         ed25519_instruction::new_ed25519_instruction,
         hash::Hash,
@@ -38,7 +38,7 @@ fn create_test_transactions(message_length: u16) -> Vec<Transaction> {
 
 #[bench]
 fn bench_ed25519_len_032(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(32);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -52,7 +52,7 @@ fn bench_ed25519_len_032(b: &mut Bencher) {
 
 #[bench]
 fn bench_ed25519_len_128(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(128);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -66,7 +66,7 @@ fn bench_ed25519_len_128(b: &mut Bencher) {
 
 #[bench]
 fn bench_ed25519_len_32k(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(32 * 1024);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -81,7 +81,7 @@ fn bench_ed25519_len_32k(b: &mut Bencher) {
 #[bench]
 fn bench_ed25519_len_max(b: &mut Bencher) {
     let required_extra_space = 113_u16; // len for pubkey, sig, and offsets
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(u16::MAX - required_extra_space);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
diff --git a/sdk/benches/secp256k1_instructions.rs b/sdk/benches/secp256k1_instructions.rs
index 8940bda5a..9c0351697 100644
--- a/sdk/benches/secp256k1_instructions.rs
+++ b/sdk/benches/secp256k1_instructions.rs
@@ -3,7 +3,7 @@
 extern crate test;
 use {
     rand0_7::{thread_rng, Rng},
-    solana_feature_set::FeatureSet,
+    solana_feature_set_interface::PrecompileFeatureSet,
     solana_sdk::{
         hash::Hash,
         secp256k1_instruction::new_secp256k1_instruction,
@@ -38,7 +38,7 @@ fn create_test_transactions(message_length: u16) -> Vec<Transaction> {
 
 #[bench]
 fn bench_secp256k1_len_032(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(32);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -52,7 +52,7 @@ fn bench_secp256k1_len_032(b: &mut Bencher) {
 
 #[bench]
 fn bench_secp256k1_len_256(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(256);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -66,7 +66,7 @@ fn bench_secp256k1_len_256(b: &mut Bencher) {
 
 #[bench]
 fn bench_secp256k1_len_32k(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(32 * 1024);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -81,7 +81,7 @@ fn bench_secp256k1_len_32k(b: &mut Bencher) {
 #[bench]
 fn bench_secp256k1_len_max(b: &mut Bencher) {
     let required_extra_space = 113_u16; // len for pubkey, sig, and offsets
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(u16::MAX - required_extra_space);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
diff --git a/sdk/benches/secp256r1_instructions.rs b/sdk/benches/secp256r1_instructions.rs
index 9af312688..aef349f61 100644
--- a/sdk/benches/secp256r1_instructions.rs
+++ b/sdk/benches/secp256r1_instructions.rs
@@ -7,7 +7,7 @@ use {
         nid::Nid,
     },
     rand0_7::{thread_rng, Rng},
-    solana_feature_set::FeatureSet,
+    solana_feature_set_interface::PrecompileFeatureSet,
     solana_sdk::{
         hash::Hash,
         signature::{Keypair, Signer},
@@ -43,7 +43,7 @@ fn create_test_transactions(message_length: u16) -> Vec<Transaction> {
 
 #[bench]
 fn bench_secp256r1_len_032(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(32);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -57,7 +57,7 @@ fn bench_secp256r1_len_032(b: &mut Bencher) {
 
 #[bench]
 fn bench_secp256r1_len_256(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(256);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -71,7 +71,7 @@ fn bench_secp256r1_len_256(b: &mut Bencher) {
 
 #[bench]
 fn bench_secp256r1_len_32k(b: &mut Bencher) {
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(32 * 1024);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
@@ -86,7 +86,7 @@ fn bench_secp256r1_len_32k(b: &mut Bencher) {
 #[bench]
 fn bench_secp256r1_len_max(b: &mut Bencher) {
     let required_extra_space = 113_u16; // len for pubkey, sig, and offsets
-    let feature_set = FeatureSet::all_enabled();
+    let feature_set = PrecompileFeatureSet::all_enabled();
     let txs = create_test_transactions(u16::MAX - required_extra_space);
     let mut tx_iter = txs.iter().cycle();
     b.iter(|| {
diff --git a/secp256k1-program/Cargo.toml b/secp256k1-program/Cargo.toml
index e0440293d..37aceadfa 100644
--- a/secp256k1-program/Cargo.toml
+++ b/secp256k1-program/Cargo.toml
@@ -16,7 +16,7 @@ libsecp256k1 = { workspace = true, features = ["hmac"] }
 serde = { workspace = true, optional = true }
 serde_derive = { workspace = true, optional = true }
 sha3 = { workspace = true }
-solana-feature-set = { workspace = true, optional = true }
+solana-feature-set-interface = { workspace = true, optional = true }
 solana-instruction = { workspace = true, features = ["std"], optional = true }
 solana-precompile-error = { workspace = true, optional = true }
 solana-sdk-ids = { workspace = true, optional = true }
@@ -40,7 +40,7 @@ solana-signer = { workspace = true }
 [features]
 bincode = [
     "dep:bincode",
-    "dep:solana-feature-set",
+    "dep:solana-feature-set-interface",
     "dep:solana-instruction",
     "dep:solana-precompile-error",
     "dep:solana-sdk-ids",
diff --git a/secp256k1-program/src/lib.rs b/secp256k1-program/src/lib.rs
index 7aad00809..2330af02f 100644
--- a/secp256k1-program/src/lib.rs
+++ b/secp256k1-program/src/lib.rs
@@ -913,7 +913,7 @@ pub fn construct_eth_pubkey(
 pub fn verify(
     data: &[u8],
     instruction_datas: &[&[u8]],
-    _feature_set: &solana_feature_set::FeatureSet,
+    _feature_set: &solana_feature_set_interface::PrecompileFeatureSet,
 ) -> Result<(), PrecompileError> {
     if data.is_empty() {
         return Err(PrecompileError::InvalidInstructionDataSize);
@@ -1021,7 +1021,7 @@ pub mod test {
     use {
         super::*,
         rand0_7::{thread_rng, Rng},
-        solana_feature_set::FeatureSet,
+        solana_feature_set_interface::PrecompileFeatureSet,
         solana_hash::Hash,
         solana_keccak_hasher as keccak,
         solana_keypair::Keypair,
@@ -1037,7 +1037,7 @@ pub mod test {
         instruction_data[0] = num_signatures;
         let writer = std::io::Cursor::new(&mut instruction_data[1..]);
         bincode::serialize_into(writer, &offsets).unwrap();
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
         verify(&instruction_data, &[&[0u8; 100]], &feature_set)
     }
 
@@ -1051,7 +1051,7 @@ pub mod test {
         let writer = std::io::Cursor::new(&mut instruction_data[1..]);
         bincode::serialize_into(writer, &offsets).unwrap();
         instruction_data.truncate(instruction_data.len() - 1);
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
 
         assert_eq!(
             verify(&instruction_data, &[&[0u8; 100]], &feature_set),
@@ -1180,7 +1180,7 @@ pub mod test {
         instruction_data[0] = 0;
         let writer = std::io::Cursor::new(&mut instruction_data[1..]);
         bincode::serialize_into(writer, &offsets).unwrap();
-        let feature_set = FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
 
         assert_eq!(
             verify(&instruction_data, &[&[0u8; 100]], &feature_set),
@@ -1201,7 +1201,7 @@ pub mod test {
         let message_arr = b"hello";
         let mut secp_instruction = new_secp256k1_instruction(&secp_privkey, message_arr);
         let mint_keypair = Keypair::new();
-        let feature_set = solana_feature_set::FeatureSet::all_enabled();
+        let feature_set = PrecompileFeatureSet::all_enabled();
 
         let tx = Transaction::new_signed_with_payer(
             &[secp_instruction.clone()],
@@ -1288,7 +1288,7 @@ pub mod test {
         verify(
             &instruction_data,
             &[&instruction_data],
-            &FeatureSet::all_enabled(),
+            &PrecompileFeatureSet::all_enabled(),
         )
         .unwrap();
     }
diff --git a/secp256r1-program/Cargo.toml b/secp256r1-program/Cargo.toml
index 5cdfcdfe5..c8f9c402d 100644
--- a/secp256r1-program/Cargo.toml
+++ b/secp256r1-program/Cargo.toml
@@ -11,7 +11,7 @@ edition = { workspace = true }
 
 [dependencies]
 bytemuck = { workspace = true, features = ["derive"] }
-solana-feature-set = { workspace = true }
+solana-feature-set-interface = { workspace = true }
 solana-precompile-error = { workspace = true }
 solana-sdk-ids = { workspace = true }
 
diff --git a/secp256r1-program/src/lib.rs b/secp256r1-program/src/lib.rs
index 65d4ab1b9..a23dc312a 100644
--- a/secp256r1-program/src/lib.rs
+++ b/secp256r1-program/src/lib.rs
@@ -50,7 +50,7 @@ mod target_arch {
             pkey::{PKey, Private},
             sign::{Signer, Verifier},
         },
-        solana_feature_set::FeatureSet,
+        solana_feature_set_interface::PrecompileFeatureSet,
         solana_instruction::Instruction,
         solana_precompile_error::PrecompileError,
     };
@@ -179,7 +179,7 @@ mod target_arch {
     pub fn verify(
         data: &[u8],
         instruction_datas: &[&[u8]],
-        _feature_set: &FeatureSet,
+        _feature_set: &PrecompileFeatureSet,
     ) -> Result<(), PrecompileError> {
         if data.len() < SIGNATURE_OFFSETS_START {
             return Err(PrecompileError::InvalidInstructionDataSize);
@@ -329,7 +329,7 @@ mod target_arch {
     mod test {
         use {
             super::*,
-            solana_feature_set::FeatureSet,
+            solana_feature_set_interface::PrecompileFeatureSet,
             solana_sdk::{
                 hash::Hash,
                 signature::{Keypair, Signer},
@@ -353,7 +353,7 @@ mod target_arch {
             verify(
                 &instruction_data,
                 &[&[0u8; 100]],
-                &FeatureSet::all_enabled(),
+                &PrecompileFeatureSet::all_enabled(),
             )
         }
 
@@ -372,7 +372,7 @@ mod target_arch {
                 verify(
                     &instruction_data,
                     &[&[0u8; 100]],
-                    &FeatureSet::all_enabled()
+                    &PrecompileFeatureSet::all_enabled()
                 ),
                 Err(PrecompileError::InvalidInstructionDataSize)
             );
@@ -412,7 +412,7 @@ mod target_arch {
             // Test data.len() < SIGNATURE_OFFSETS_START
             let small_data = vec![0u8; SIGNATURE_OFFSETS_START - 1];
             assert_eq!(
-                verify(&small_data, &[&[]], &FeatureSet::all_enabled()),
+                verify(&small_data, &[&[]], &PrecompileFeatureSet::all_enabled()),
                 Err(PrecompileError::InvalidInstructionDataSize)
             );
 
@@ -420,7 +420,11 @@ mod target_arch {
             let mut zero_sigs_data = vec![0u8; DATA_START];
             zero_sigs_data[0] = 0; // Set num_signatures to 0
             assert_eq!(
-                verify(&zero_sigs_data, &[&[]], &FeatureSet::all_enabled()),
+                verify(
+                    &zero_sigs_data,
+                    &[&[]],
+                    &PrecompileFeatureSet::all_enabled()
+                ),
                 Err(PrecompileError::InvalidInstructionDataSize)
             );
 
@@ -428,7 +432,7 @@ mod target_arch {
             let mut too_many_sigs = vec![0u8; DATA_START];
             too_many_sigs[0] = 9; // Set num_signatures to 9
             assert_eq!(
-                verify(&too_many_sigs, &[&[]], &FeatureSet::all_enabled()),
+                verify(&too_many_sigs, &[&[]], &PrecompileFeatureSet::all_enabled()),
                 Err(PrecompileError::InvalidInstructionDataSize)
             );
         }
@@ -525,7 +529,7 @@ mod target_arch {
             let signing_key = EcKey::generate(&group).unwrap();
             let mut instruction = new_secp256r1_instruction(message_arr, signing_key).unwrap();
             let mint_keypair = Keypair::new();
-            let feature_set = FeatureSet::all_enabled();
+            let feature_set = PrecompileFeatureSet::all_enabled();
 
             let tx = Transaction::new_signed_with_payer(
                 &[instruction.clone()],
@@ -560,7 +564,7 @@ mod target_arch {
             let mut instruction = new_secp256r1_instruction(message_arr, signing_key).unwrap();
 
             // To double check that the untampered low-S value signature passes
-            let feature_set = FeatureSet::all_enabled();
+            let feature_set = PrecompileFeatureSet::all_enabled();
             let tx_pass = verify(
                 instruction.data.as_slice(),
                 &[instruction.data.as_slice()],
@@ -628,7 +632,7 @@ mod target_arch {
                         Hash::default(),
                     );
 
-                    let feature_set = FeatureSet::all_enabled();
+                    let feature_set = PrecompileFeatureSet::all_enabled();
                     assert!(tx.verify_precompiles(&feature_set).is_ok());
                     break;
                 }
@@ -738,12 +742,15 @@ mod target_arch {
 
 #[cfg(any(target_arch = "wasm32", target_os = "solana"))]
 mod target_arch {
-    use {solana_feature_set::FeatureSet, solana_precompile_error::PrecompileError};
+    use {
+        solana_feature_set_interface::PrecompileFeatureSet,
+        solana_precompile_error::PrecompileError,
+    };
 
     pub fn verify(
         _data: &[u8],
         _instruction_datas: &[&[u8]],
-        _feature_set: &FeatureSet,
+        _feature_set: &PrecompileFeatureSet,
     ) -> Result<(), PrecompileError> {
         Err(PrecompileError::InvalidSignature)
     }
diff --git a/transaction/Cargo.toml b/transaction/Cargo.toml
index c00ed92e7..05b7e0a18 100644
--- a/transaction/Cargo.toml
+++ b/transaction/Cargo.toml
@@ -14,7 +14,7 @@ bincode = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 serde_derive = { workspace = true, optional = true }
 solana-bincode = { workspace = true, optional = true }
-solana-feature-set = { workspace = true, optional = true }
+solana-feature-set-interface = { workspace = true, optional = true }
 solana-frozen-abi = { workspace = true, optional = true }
 solana-frozen-abi-macro = { workspace = true, optional = true }
 solana-hash = { workspace = true }
@@ -73,7 +73,7 @@ frozen-abi = [
     "dep:solana-frozen-abi-macro",
     "dep:solana-logger",
 ]
-precompiles = ["dep:solana-feature-set", "dep:solana-precompiles"]
+precompiles = ["dep:solana-feature-set-interface", "dep:solana-precompiles"]
 serde = [
     "dep:serde",
     "dep:serde_derive",
diff --git a/transaction/src/lib.rs b/transaction/src/lib.rs
index 43a913843..4af233601 100644
--- a/transaction/src/lib.rs
+++ b/transaction/src/lib.rs
@@ -1059,7 +1059,10 @@ impl Transaction {
 
     #[cfg(feature = "precompiles")]
     /// Verify the precompiled programs in this transaction.
-    pub fn verify_precompiles(&self, feature_set: &solana_feature_set::FeatureSet) -> Result<()> {
+    pub fn verify_precompiles(
+        &self,
+        feature_set: &solana_feature_set_interface::PrecompileFeatureSet,
+    ) -> Result<()> {
         for instruction in &self.message().instructions {
             // The Transaction may not be sanitized at this point
             if instruction.program_id_index as usize >= self.message().account_keys.len() {
diff --git a/transaction/src/sanitized.rs b/transaction/src/sanitized.rs
index 2d0f3639c..35e271bac 100644
--- a/transaction/src/sanitized.rs
+++ b/transaction/src/sanitized.rs
@@ -288,7 +288,10 @@ impl SanitizedTransaction {
 
     #[cfg(feature = "precompiles")]
     /// Verify the precompiled programs in this transaction
-    pub fn verify_precompiles(&self, feature_set: &solana_feature_set::FeatureSet) -> Result<()> {
+    pub fn verify_precompiles(
+        &self,
+        feature_set: &solana_feature_set_interface::PrecompileFeatureSet,
+    ) -> Result<()> {
         for (index, (program_id, instruction)) in
             self.message.program_instructions_iter().enumerate()
         {