Unifies the runtimes Builtin and program runtimes BuiltinProgram defi…

…nitions.

program-runtime/src/builtin_program.rs

@@ -1,22 +1,37 @@
+#[cfg(RUSTC_WITH_SPECIALIZATION)]
+use {crate::declare_process_instruction, solana_frozen_abi::abi_example::AbiExample};
 use {
-    crate::invoke_context::InvokeContext, solana_frozen_abi::abi_example::AbiExample,
-    solana_rbpf::vm::BuiltInFunction, solana_sdk::pubkey::Pubkey,
+    crate::invoke_context::InvokeContext, solana_rbpf::vm::BuiltInFunction,
+    solana_sdk::pubkey::Pubkey,
 };
 
 pub type ProcessInstructionWithContext = BuiltInFunction<InvokeContext<'static>>;
 
 #[derive(Clone)]
 pub struct BuiltinProgram {
+    pub name: String,
     pub program_id: Pubkey,
     pub process_instruction: ProcessInstructionWithContext,
 }
 
 impl std::fmt::Debug for BuiltinProgram {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "{}: {:p}",
-            self.program_id, self.process_instruction as *const ProcessInstructionWithContext,
-        )
+        write!(f, "Builtin [name={}, id={}]", self.name, self.program_id)
+    }
+}
+
+#[cfg(RUSTC_WITH_SPECIALIZATION)]
+impl AbiExample for BuiltinProgram {
+    fn example() -> Self {
+        declare_process_instruction!(empty_mock_process_instruction, 1, |_invoke_context| {
+            // Do nothing
+            Ok(())
+        });
+
+        Self {
+            name: String::default(),
+            program_id: Pubkey::default(),
+            process_instruction: empty_mock_process_instruction,
+        }
     }
 }

program-runtime/src/invoke_context.rs

@@ -964,6 +964,7 @@ pub fn mock_process_instruction<F: FnMut(&mut InvokeContext), G: FnMut(&mut Invo
     transaction_accounts.push((*loader_id, processor_account));
     with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
     let builtin_programs = &[BuiltinProgram {
+        name: "mock instruction processor".to_string(),
         program_id: *loader_id,
         process_instruction,
     }];
@@ -1217,6 +1218,7 @@ mod tests {
             .collect::<Vec<_>>();
         with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
         let builtin_programs = &[BuiltinProgram {
+            name: "mock instruction processor".to_string(),
             program_id: callee_program_id,
             process_instruction,
         }];
@@ -1362,6 +1364,7 @@ mod tests {
         ];
         with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
         let builtin_programs = &[BuiltinProgram {
+            name: "mock instruction processor".to_string(),
             program_id: program_key,
             process_instruction,
         }];

runtime/src/bank.rs

@@ -6631,8 +6631,8 @@ impl Bank {
             for builtin in builtins.genesis_builtins {
                 self.add_builtin(
                     &builtin.name,
-                    &builtin.id,
-                    builtin.process_instruction_with_context,
+                    &builtin.program_id,
+                    builtin.process_instruction,
                 );
             }
             for precompile in get_precompiles() {
@@ -7674,6 +7674,7 @@ impl Bank {
             entry.process_instruction = process_instruction;
         } else {
             self.builtin_programs.vec.push(BuiltinProgram {
+                name: name.to_string(),
                 program_id: *program_id,
                 process_instruction,
             });
@@ -7944,8 +7945,8 @@ impl Bank {
                 match builtin_action {
                     BuiltinAction::Add(builtin) => self.add_builtin(
                         &builtin.name,
-                        &builtin.id,
-                        builtin.process_instruction_with_context,
+                        &builtin.program_id,
+                        builtin.process_instruction,
                     ),
                     BuiltinAction::Remove(program_id) => self.remove_builtin(&program_id),
                 }

runtime/src/builtins.rs

@@ -1,60 +1,12 @@
-#[cfg(RUSTC_WITH_SPECIALIZATION)]
 use {
-    solana_frozen_abi::abi_example::AbiExample, solana_program_runtime::declare_process_instruction,
-};
-use {
-    solana_program_runtime::builtin_program::ProcessInstructionWithContext,
+    solana_program_runtime::builtin_program::BuiltinProgram,
     solana_sdk::{feature_set, pubkey::Pubkey, stake},
-    std::fmt,
 };
 
-#[derive(Clone)]
-pub struct Builtin {
-    pub name: String,
-    pub id: Pubkey,
-    pub process_instruction_with_context: ProcessInstructionWithContext,
-}
-
-impl Builtin {
-    pub fn new(
-        name: &str,
-        id: Pubkey,
-        process_instruction_with_context: ProcessInstructionWithContext,
-    ) -> Self {
-        Self {
-            name: name.to_string(),
-            id,
-            process_instruction_with_context,
-        }
-    }
-}
-
-impl fmt::Debug for Builtin {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Builtin [name={}, id={}]", self.name, self.id)
-    }
-}
-
-#[cfg(RUSTC_WITH_SPECIALIZATION)]
-impl AbiExample for Builtin {
-    fn example() -> Self {
-        declare_process_instruction!(process_instruction, 1, |_invoke_context| {
-            // Do nothing
-            Ok(())
-        });
-
-        Self {
-            name: String::default(),
-            id: Pubkey::default(),
-            process_instruction_with_context: process_instruction,
-        }
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct Builtins {
     /// Builtin programs that are always available
-    pub genesis_builtins: Vec<Builtin>,
+    pub genesis_builtins: Vec<BuiltinProgram>,
 
     /// Dynamic feature transitions for builtin programs
     pub feature_transitions: Vec<BuiltinFeatureTransition>,
@@ -63,7 +15,7 @@ pub struct Builtins {
 /// Actions taken by a bank when managing the list of active builtin programs.
 #[derive(Debug, Clone)]
 pub enum BuiltinAction {
-    Add(Builtin),
+    Add(BuiltinProgram),
     Remove(Pubkey),
 }
 
@@ -73,13 +25,13 @@ pub enum BuiltinAction {
 pub enum BuiltinFeatureTransition {
     /// Add a builtin program if a feature is activated.
     Add {
-        builtin: Builtin,
+        builtin: BuiltinProgram,
         feature_id: Pubkey,
     },
     /// Remove a builtin program if a feature is activated or
     /// retain a previously added builtin.
     RemoveOrRetain {
-        previously_added_builtin: Builtin,
+        previously_added_builtin: BuiltinProgram,
         addition_feature_id: Pubkey,
         removal_feature_id: Pubkey,
     },
@@ -107,7 +59,7 @@ impl BuiltinFeatureTransition {
                 removal_feature_id,
             } => {
                 if should_apply_action_for_feature(removal_feature_id) {
-                    Some(BuiltinAction::Remove(previously_added_builtin.id))
+                    Some(BuiltinAction::Remove(previously_added_builtin.program_id))
                 } else if should_apply_action_for_feature(addition_feature_id) {
                     // Retaining is no different from adding a new builtin.
                     Some(BuiltinAction::Add(previously_added_builtin.clone()))
@@ -119,57 +71,58 @@ impl BuiltinFeatureTransition {
     }
 }
 
-/// Builtin programs that are always available
-fn genesis_builtins() -> Vec<Builtin> {
+/// Built-in programs that are always available
+fn genesis_builtins() -> Vec<BuiltinProgram> {
     vec![
-        Builtin::new(
-            "system_program",
-            solana_system_program::id(),
-            solana_system_program::system_processor::process_instruction,
-        ),
-        Builtin::new(
-            "vote_program",
-            solana_vote_program::id(),
-            solana_vote_program::vote_processor::process_instruction,
-        ),
-        Builtin::new(
-            "stake_program",
-            stake::program::id(),
-            solana_stake_program::stake_instruction::process_instruction,
-        ),
-        Builtin::new(
-            "config_program",
-            solana_config_program::id(),
-            solana_config_program::config_processor::process_instruction,
-        ),
+        BuiltinProgram {
+            name: "system_program".to_string(),
+            program_id: solana_system_program::id(),
+            process_instruction: solana_system_program::system_processor::process_instruction,
+        },
+        BuiltinProgram {
+            name: "vote_program".to_string(),
+            program_id: solana_vote_program::id(),
+            process_instruction: solana_vote_program::vote_processor::process_instruction,
+        },
+        BuiltinProgram {
+            name: "stake_program".to_string(),
+            program_id: stake::program::id(),
+            process_instruction: solana_stake_program::stake_instruction::process_instruction,
+        },
+        BuiltinProgram {
+            name: "config_program".to_string(),
+            program_id: solana_config_program::id(),
+            process_instruction: solana_config_program::config_processor::process_instruction,
+        },
     ]
 }
 
 /// Dynamic feature transitions for builtin programs
 fn builtin_feature_transitions() -> Vec<BuiltinFeatureTransition> {
     vec![
         BuiltinFeatureTransition::Add {
-            builtin: Builtin::new(
-                "compute_budget_program",
-                solana_sdk::compute_budget::id(),
-                solana_compute_budget_program::process_instruction,
-            ),
+            builtin: BuiltinProgram {
+                name: "compute_budget_program".to_string(),
+                program_id: solana_sdk::compute_budget::id(),
+                process_instruction: solana_compute_budget_program::process_instruction,
+            },
             feature_id: feature_set::add_compute_budget_program::id(),
         },
         BuiltinFeatureTransition::Add {
-            builtin: Builtin::new(
-                "address_lookup_table_program",
-                solana_address_lookup_table_program::id(),
-                solana_address_lookup_table_program::processor::process_instruction,
-            ),
+            builtin: BuiltinProgram {
+                name: "address_lookup_table_program".to_string(),
+                program_id: solana_address_lookup_table_program::id(),
+                process_instruction:
+                    solana_address_lookup_table_program::processor::process_instruction,
+            },
             feature_id: feature_set::versioned_tx_message_enabled::id(),
         },
         BuiltinFeatureTransition::Add {
-            builtin: Builtin::new(
-                "zk_token_proof_program",
-                solana_zk_token_sdk::zk_token_proof_program::id(),
-                solana_zk_token_proof_program::process_instruction,
-            ),
+            builtin: BuiltinProgram {
+                name: "zk_token_proof_program".to_string(),
+                program_id: solana_zk_token_sdk::zk_token_proof_program::id(),
+                process_instruction: solana_zk_token_proof_program::process_instruction,
+            },
             feature_id: feature_set::zk_token_sdk_enabled::id(),
         },
     ]
@@ -187,9 +140,9 @@ pub fn get_pubkeys() -> Vec<Pubkey> {
     let builtins = get();
 
     let mut pubkeys = Vec::new();
-    pubkeys.extend(builtins.genesis_builtins.iter().map(|b| b.id));
+    pubkeys.extend(builtins.genesis_builtins.iter().map(|b| b.program_id));
     pubkeys.extend(builtins.feature_transitions.iter().filter_map(|f| match f {
-        BuiltinFeatureTransition::Add { builtin, .. } => Some(builtin.id),
+        BuiltinFeatureTransition::Add { builtin, .. } => Some(builtin.program_id),
         BuiltinFeatureTransition::RemoveOrRetain { .. } => None,
     }));
     pubkeys

runtime/src/message_processor.rs

@@ -253,6 +253,7 @@ mod tests {
 
         let rent_collector = RentCollector::default();
         let builtin_programs = &[BuiltinProgram {
+            name: "mock instruction processor".to_string(),
             program_id: mock_system_program_id,
             process_instruction,
         }];
@@ -480,6 +481,7 @@ mod tests {
         let mock_program_id = Pubkey::from([2u8; 32]);
         let rent_collector = RentCollector::default();
         let builtin_programs = &[BuiltinProgram {
+            name: "mock instruction processor".to_string(),
             program_id: mock_program_id,
             process_instruction,
         }];
@@ -643,6 +645,7 @@ mod tests {
             Err(InstructionError::Custom(0xbabb1e))
         });
         let builtin_programs = &[BuiltinProgram {
+            name: "mock instruction processor".to_string(),
             program_id: mock_program_id,
             process_instruction,
         }];