Native/builtin programs now receive an InvokeContext

sdk/src/entrypoint_native.rs

@@ -86,15 +86,19 @@ macro_rules! declare_name {
 /// # // wrapper is used so that the macro invocation occurs in the item position
 /// # // rather than in the statement position which isn't allowed.
 /// # mod item_wrapper {
-/// use solana_sdk::keyed_account::KeyedAccount;
-/// use solana_sdk::instruction::InstructionError;
-/// use solana_sdk::pubkey::Pubkey;
-/// use solana_sdk::declare_program;
+/// use solana_sdk::{
+///     declare_program,
+///     instruction::InstructionError,
+///     keyed_account::KeyedAccount,
+///     process_instruction::InvokeContext,
+///     pubkey::Pubkey,
+/// };
 ///
 /// fn my_process_instruction(
 ///     program_id: &Pubkey,
 ///     keyed_accounts: &[KeyedAccount],
 ///     instruction_data: &[u8],
+///     invoke_context: &mut dyn InvokeContext,
 /// ) -> Result<(), InstructionError> {
 ///   // Process an instruction
 ///   Ok(())
@@ -117,15 +121,19 @@ macro_rules! declare_name {
 /// # // wrapper is used so that the macro invocation occurs in the item position
 /// # // rather than in the statement position which isn't allowed.
 /// # mod item_wrapper {
-/// use solana_sdk::keyed_account::KeyedAccount;
-/// use solana_sdk::instruction::InstructionError;
-/// use solana_sdk::pubkey::Pubkey;
-/// use solana_sdk::declare_program;
+/// use solana_sdk::{
+///     declare_program,
+///     instruction::InstructionError,
+///     keyed_account::KeyedAccount,
+///     process_instruction::InvokeContext,
+///     pubkey::Pubkey,
+/// };
 ///
 /// fn my_process_instruction(
 ///     program_id: &Pubkey,
 ///     keyed_accounts: &[KeyedAccount],
 ///     instruction_data: &[u8],
+///     invoke_context: &mut dyn InvokeContext,
 /// ) -> Result<(), InstructionError> {
 ///   // Process an instruction
 ///   Ok(())
@@ -152,8 +160,9 @@ macro_rules! declare_program(
             program_id: &$crate::pubkey::Pubkey,
             keyed_accounts: &[$crate::keyed_account::KeyedAccount],
             instruction_data: &[u8],
+            invoke_context: &mut dyn $crate::process_instruction::InvokeContext,
         ) -> Result<(), $crate::instruction::InstructionError> {
-            $entrypoint(program_id, keyed_accounts, instruction_data)
+            $entrypoint(program_id, keyed_accounts, instruction_data, invoke_context)
         }
     )
 );

sdk/src/feature.rs

@@ -0,0 +1,79 @@
+use solana_sdk::{account::Account, clock::Slot};
+
+solana_sdk::declare_id!("Feature111111111111111111111111111111111111");
+
+/// The `Feature` struct is the on-chain representation of a runtime feature.
+///
+/// Feature activation is accomplished by:
+/// 1. Activation is requested by the feature authority, who issues a transaction to create the
+///    feature account.  The newly created feature account will have the value of
+///    `Feature::default()`
+/// 2. When the next epoch is entered the runtime will check for new activation requests and
+///    active them.  When this occurs, the activation slot is recorded in the feature account
+///
+#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
+pub struct Feature {
+    pub activated_at: Option<Slot>,
+}
+
+impl Feature {
+    pub fn size_of() -> usize {
+        bincode::serialized_size(&Self {
+            activated_at: Some(0),
+        })
+        .unwrap() as usize
+    }
+    pub fn from_account(account: &Account) -> Option<Self> {
+        if account.owner != id() {
+            None
+        } else {
+            bincode::deserialize(&account.data).ok()
+        }
+    }
+    pub fn to_account(&self, account: &mut Account) -> Option<()> {
+        bincode::serialize_into(&mut account.data[..], self).ok()
+    }
+    pub fn create_account(&self, lamports: u64) -> Account {
+        let data_len = Self::size_of().max(bincode::serialized_size(self).unwrap() as usize);
+        let mut account = Account::new(lamports, data_len, &id());
+        self.to_account(&mut account).unwrap();
+        account
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn feature_deserialize_none() {
+        let just_initialized = Account::new(42, Feature::size_of(), &id());
+        assert_eq!(
+            Feature::from_account(&just_initialized),
+            Some(Feature { activated_at: None })
+        );
+    }
+
+    #[test]
+    fn feature_sizeof() {
+        assert!(
+            Feature::size_of() >= bincode::serialized_size(&Feature::default()).unwrap() as usize
+        );
+        assert_eq!(Feature::default(), Feature { activated_at: None });
+
+        let features = [
+            Feature {
+                activated_at: Some(0),
+            },
+            Feature {
+                activated_at: Some(Slot::MAX),
+            },
+        ];
+        for feature in &features {
+            assert_eq!(
+                Feature::size_of(),
+                bincode::serialized_size(feature).unwrap() as usize
+            );
+        }
+    }
+}

sdk/src/feature_set.rs

@@ -0,0 +1,155 @@
+use lazy_static::lazy_static;
+use solana_sdk::{
+    clock::Slot,
+    hash::{Hash, Hasher},
+    pubkey::Pubkey,
+};
+use std::collections::{HashMap, HashSet};
+
+pub mod instructions_sysvar_enabled {
+    solana_sdk::declare_id!("EnvhHCLvg55P7PDtbvR1NwuTuAeodqpusV3MR5QEK8gs");
+}
+
+pub mod secp256k1_program_enabled {
+    solana_sdk::declare_id!("E3PHP7w8kB7np3CTQ1qQ2tW3KCtjRSXBQgW9vM2mWv2Y");
+}
+
+pub mod consistent_recent_blockhashes_sysvar {
+    solana_sdk::declare_id!("3h1BQWPDS5veRsq6mDBWruEpgPxRJkfwGexg5iiQ9mYg");
+}
+
+pub mod pico_inflation {
+    solana_sdk::declare_id!("GaBtBJvmS4Arjj5W1NmFcyvPjsHN38UGYDq2MDwbs9Qu");
+}
+
+pub mod inflation_kill_switch {
+    solana_sdk::declare_id!("SECCKV5UVUsr8sTVSVAzULjdm87r7mLPaqH2FGZjevR");
+}
+
+pub mod spl_token_v2_multisig_fix {
+    solana_sdk::declare_id!("E5JiFDQCwyC6QfT9REFyMpfK2mHcmv1GUDySU1Ue7TYv");
+}
+
+pub mod bpf_loader2_program {
+    solana_sdk::declare_id!("DFBnrgThdzH4W6wZ12uGPoWcMnvfZj11EHnxHcVxLPhD");
+}
+
+pub mod compute_budget_balancing {
+    solana_sdk::declare_id!("HxvjqDSiF5sYdSYuCXsUnS8UeAoWsMT9iGoFP8pgV1mB");
+}
+
+pub mod sha256_syscall_enabled {
+    solana_sdk::declare_id!("D7KfP7bZxpkYtD4Pc38t9htgs1k5k47Yhxe4rp6WDVi8");
+}
+
+pub mod no_overflow_rent_distribution {
+    solana_sdk::declare_id!("4kpdyrcj5jS47CZb2oJGfVxjYbsMm2Kx97gFyZrxxwXz");
+}
+
+pub mod ristretto_mul_syscall_enabled {
+    solana_sdk::declare_id!("HRe7A6aoxgjKzdjbBv6HTy7tJ4YWqE6tVmYCGho6S9Aq");
+}
+
+pub mod max_invoke_depth_4 {
+    solana_sdk::declare_id!("EdM9xggY5y7AhNMskRG8NgGMnaP4JFNsWi8ZZtyT1af5");
+}
+
+pub mod max_program_call_depth_64 {
+    solana_sdk::declare_id!("YCKSgA6XmjtkQrHBQjpyNrX6EMhJPcYcLWMVgWn36iv");
+}
+
+pub mod timestamp_correction {
+    solana_sdk::declare_id!("3zydSLUwuqqsV3wL5wBsaVgyvMox3XTHx7zLEuQf1U2Z");
+}
+
+pub mod cumulative_rent_related_fixes {
+    solana_sdk::declare_id!("FtjnuAtJTWwX3Kx9m24LduNEhzaGuuPfDW6e14SX2Fy5");
+}
+
+pub mod pubkey_log_syscall_enabled {
+    solana_sdk::declare_id!("MoqiU1vryuCGQSxFKA1SZ316JdLEFFhoAu6cKUNk7dN");
+}
+
+pub mod pull_request_ping_pong_check {
+    solana_sdk::declare_id!("5RzEHTnf6D7JPZCvwEzjM19kzBsyjSU3HoMfXaQmVgnZ");
+}
+
+pub mod bpf_just_in_time_compilation {
+    solana_sdk::declare_id!("3bZhti6PMmsdkPxqPT8TPNzB3n9NYbKtnwqEpUDnFuPi");
+}
+
+lazy_static! {
+    /// Map of feature identifiers to user-visible description
+    pub static ref FEATURE_NAMES: HashMap<Pubkey, &'static str> = [
+        (instructions_sysvar_enabled::id(), "instructions sysvar"),
+        (secp256k1_program_enabled::id(), "secp256k1 program"),
+        (consistent_recent_blockhashes_sysvar::id(), "consistent recentblockhashes sysvar"),
+        (pico_inflation::id(), "pico-inflation"),
+        (inflation_kill_switch::id(), "inflation kill switch"),
+        (spl_token_v2_multisig_fix::id(), "spl-token multisig fix"),
+        (bpf_loader2_program::id(), "bpf_loader2 program"),
+        (compute_budget_balancing::id(), "compute budget balancing"),
+        (sha256_syscall_enabled::id(), "sha256 syscall"),
+        (no_overflow_rent_distribution::id(), "no overflow rent distribution"),
+        (ristretto_mul_syscall_enabled::id(), "ristretto multiply syscall"),
+        (max_invoke_depth_4::id(), "max invoke call depth 4"),
+        (max_program_call_depth_64::id(), "max program call depth 64"),
+        (timestamp_correction::id(), "correct bank timestamps"),
+        (cumulative_rent_related_fixes::id(), "rent fixes (#10206, #10468, #11342)"),
+        (pubkey_log_syscall_enabled::id(), "pubkey log syscall"),
+        (pull_request_ping_pong_check::id(), "ping-pong packet check #12794"),
+        (bpf_just_in_time_compilation::id(), "bpf just-in-time compilation #12951"),
+        /*************** ADD NEW FEATURES HERE ***************/
+    ]
+    .iter()
+    .cloned()
+    .collect();
+
+    /// Unique identifier of the current software's feature set
+    pub static ref ID: Hash = {
+        let mut hasher = Hasher::default();
+        let mut feature_ids = FEATURE_NAMES.keys().collect::<Vec<_>>();
+        feature_ids.sort();
+        for feature in feature_ids {
+            hasher.hash(feature.as_ref());
+        }
+        hasher.result()
+    };
+}
+
+/// `FeatureSet` holds the set of currently active/inactive runtime features
+#[derive(AbiExample, Debug, Clone)]
+pub struct FeatureSet {
+    pub active: HashMap<Pubkey, Slot>,
+    pub inactive: HashSet<Pubkey>,
+}
+impl Default for FeatureSet {
+    fn default() -> Self {
+        // All features disabled
+        Self {
+            active: HashMap::new(),
+            inactive: FEATURE_NAMES.keys().cloned().collect(),
+        }
+    }
+}
+impl FeatureSet {
+    pub fn is_active(&self, feature_id: &Pubkey) -> bool {
+        self.active.contains_key(feature_id)
+    }
+
+    pub fn activated_slot(&self, feature_id: &Pubkey) -> Option<Slot> {
+        self.active.get(feature_id).copied()
+    }
+
+    pub fn cumulative_rent_related_fixes_enabled(&self) -> bool {
+        self.is_active(&cumulative_rent_related_fixes::id())
+    }
+
+    /// All features enabled, useful for testing
+    pub fn all_enabled() -> Self {
+        Self {
+            active: FEATURE_NAMES.keys().cloned().map(|key| (key, 0)).collect(),
+            inactive: HashSet::new(),
+        }
+    }
+}

sdk/src/lib.rs

@@ -16,6 +16,8 @@ pub mod entrypoint;
 pub mod entrypoint_deprecated;
 pub mod entrypoint_native;
 pub mod epoch_info;
+pub mod feature;
+pub mod feature_set;
 pub mod genesis_config;
 pub mod hard_forks;
 pub mod hash;
@@ -27,6 +29,7 @@ pub mod nonce_account;
 pub mod nonce_keyed_account;
 pub mod packet;
 pub mod poh_config;
+pub mod process_instruction;
 pub mod program_utils;
 pub mod pubkey;
 pub mod recent_blockhashes_account;

sdk/src/process_instruction.rs

@@ -0,0 +1,268 @@
+use solana_sdk::{
+    account::Account,
+    feature_set::{
+        compute_budget_balancing, max_invoke_depth_4, max_program_call_depth_64,
+        pubkey_log_syscall_enabled, FeatureSet,
+    },
+    instruction::{CompiledInstruction, Instruction, InstructionError},
+    keyed_account::KeyedAccount,
+    message::Message,
+    pubkey::Pubkey,
+};
+use std::{cell::RefCell, fmt::Debug, rc::Rc, sync::Arc};
+
+// Prototype of a native loader entry point
+///
+/// program_id: Program ID of the currently executing program
+/// keyed_accounts: Accounts passed as part of the instruction
+/// instruction_data: Instruction data
+/// invoke_context: Invocation context
+pub type LoaderEntrypoint = unsafe extern "C" fn(
+    program_id: &Pubkey,
+    keyed_accounts: &[KeyedAccount],
+    instruction_data: &[u8],
+    invoke_context: &dyn InvokeContext,
+) -> Result<(), InstructionError>;
+
+pub type ProcessInstructionWithContext =
+    fn(&Pubkey, &[KeyedAccount], &[u8], &mut dyn InvokeContext) -> Result<(), InstructionError>;
+
+// These are just type aliases for work around of Debug-ing above function pointers
+pub type ErasedProcessInstructionWithContext = fn(
+    &'static Pubkey,
+    &'static [KeyedAccount<'static>],
+    &'static [u8],
+    &'static mut dyn InvokeContext,
+) -> Result<(), InstructionError>;
+
+/// Invocation context passed to loaders
+pub trait InvokeContext {
+    /// Push a program ID on to the invocation stack
+    fn push(&mut self, key: &Pubkey) -> Result<(), InstructionError>;
+    /// Pop a program ID off of the invocation stack
+    fn pop(&mut self);
+    /// Verify and update PreAccount state based on program execution
+    fn verify_and_update(
+        &mut self,
+        message: &Message,
+        instruction: &CompiledInstruction,
+        accounts: &[Rc<RefCell<Account>>],
+    ) -> Result<(), InstructionError>;
+    /// Get the program ID of the currently executing program
+    fn get_caller(&self) -> Result<&Pubkey, InstructionError>;
+    /// Get a list of built-in programs
+    fn get_programs(&self) -> &[(Pubkey, ProcessInstructionWithContext)];
+    /// Get this invocation's logger
+    fn get_logger(&self) -> Rc<RefCell<dyn Logger>>;
+    /// Get this invocation's compute budget
+    fn get_compute_budget(&self) -> &ComputeBudget;
+    /// Get this invocation's compute meter
+    fn get_compute_meter(&self) -> Rc<RefCell<dyn ComputeMeter>>;
+    /// Loaders may need to do work in order to execute a program.  Cache
+    /// the work that can be re-used across executions
+    fn add_executor(&mut self, pubkey: &Pubkey, executor: Arc<dyn Executor>);
+    /// Get the completed loader work that can be re-used across executions
+    fn get_executor(&mut self, pubkey: &Pubkey) -> Option<Arc<dyn Executor>>;
+    /// Record invoked instruction
+    fn record_instruction(&self, instruction: &Instruction);
+    /// Get the bank's active feature set
+    fn is_feature_active(&self, feature_id: &Pubkey) -> bool;
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct ComputeBudget {
+    /// Number of compute units that an instruction is allowed.  Compute units
+    /// are consumed by program execution, resources they use, etc...
+    pub max_units: u64,
+    /// Number of compute units consumed by a log call
+    pub log_units: u64,
+    /// Number of compute units consumed by a log_u64 call
+    pub log_64_units: u64,
+    /// Number of compute units consumed by a create_program_address call
+    pub create_program_address_units: u64,
+    /// Number of compute units consumed by an invoke call (not including the cost incurred by
+    /// the called program)
+    pub invoke_units: u64,
+    /// Maximum cross-program invocation depth allowed including the original caller
+    pub max_invoke_depth: usize,
+    /// Base number of compute units consumed to call SHA256
+    pub sha256_base_cost: u64,
+    /// Incremental number of units consumed by SHA256 (based on bytes)
+    pub sha256_byte_cost: u64,
+    /// Maximum BPF to BPF call depth
+    pub max_call_depth: usize,
+    /// Size of a stack frame in bytes, must match the size specified in the LLVM BPF backend
+    pub stack_frame_size: usize,
+    /// Number of compute units consumed by logging a `Pubkey`
+    pub log_pubkey_units: u64,
+}
+impl Default for ComputeBudget {
+    fn default() -> Self {
+        Self::new(&FeatureSet::all_enabled())
+    }
+}
+impl ComputeBudget {
+    pub fn new(feature_set: &FeatureSet) -> Self {
+        let mut compute_budget =
+        // Original
+        ComputeBudget {
+            max_units: 100_000,
+            log_units: 0,
+            log_64_units: 0,
+            create_program_address_units: 0,
+            invoke_units: 0,
+            max_invoke_depth: 1,
+            sha256_base_cost: 85,
+            sha256_byte_cost: 1,
+            max_call_depth: 20,
+            stack_frame_size: 4_096,
+            log_pubkey_units: 0,
+        };
+
+        if feature_set.is_active(&compute_budget_balancing::id()) {
+            compute_budget = ComputeBudget {
+                max_units: 200_000,
+                log_units: 100,
+                log_64_units: 100,
+                create_program_address_units: 1500,
+                invoke_units: 1000,
+                ..compute_budget
+            };
+        }
+        if feature_set.is_active(&max_invoke_depth_4::id()) {
+            compute_budget = ComputeBudget {
+                max_invoke_depth: 4,
+                ..compute_budget
+            };
+        }
+
+        if feature_set.is_active(&max_program_call_depth_64::id()) {
+            compute_budget = ComputeBudget {
+                max_call_depth: 64,
+                ..compute_budget
+            };
+        }
+        if feature_set.is_active(&pubkey_log_syscall_enabled::id()) {
+            compute_budget = ComputeBudget {
+                log_pubkey_units: 100,
+                ..compute_budget
+            };
+        }
+        compute_budget
+    }
+}
+
+/// Compute meter
+pub trait ComputeMeter {
+    /// Consume compute units
+    fn consume(&mut self, amount: u64) -> Result<(), InstructionError>;
+    /// Get the number of remaining compute units
+    fn get_remaining(&self) -> u64;
+}
+
+/// Log messages
+pub trait Logger {
+    fn log_enabled(&self) -> bool;
+    /// Log a message
+    fn log(&mut self, message: &str);
+}
+
+/// Program executor
+pub trait Executor: Debug + Send + Sync {
+    /// Execute the program
+    fn execute(
+        &self,
+        program_id: &Pubkey,
+        keyed_accounts: &[KeyedAccount],
+        instruction_data: &[u8],
+        invoke_context: &mut dyn InvokeContext,
+    ) -> Result<(), InstructionError>;
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MockComputeMeter {
+    pub remaining: u64,
+}
+impl ComputeMeter for MockComputeMeter {
+    fn consume(&mut self, amount: u64) -> Result<(), InstructionError> {
+        let exceeded = self.remaining < amount;
+        self.remaining = self.remaining.saturating_sub(amount);
+        if exceeded {
+            return Err(InstructionError::ComputationalBudgetExceeded);
+        }
+        Ok(())
+    }
+    fn get_remaining(&self) -> u64 {
+        self.remaining
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MockLogger {
+    pub log: Rc<RefCell<Vec<String>>>,
+}
+impl Logger for MockLogger {
+    fn log_enabled(&self) -> bool {
+        true
+    }
+    fn log(&mut self, message: &str) {
+        self.log.borrow_mut().push(message.to_string());
+    }
+}
+
+#[derive(Debug)]
+pub struct MockInvokeContext {
+    pub key: Pubkey,
+    pub logger: MockLogger,
+    pub compute_budget: ComputeBudget,
+    pub compute_meter: MockComputeMeter,
+}
+impl Default for MockInvokeContext {
+    fn default() -> Self {
+        MockInvokeContext {
+            key: Pubkey::default(),
+            logger: MockLogger::default(),
+            compute_budget: ComputeBudget::default(),
+            compute_meter: MockComputeMeter {
+                remaining: std::i64::MAX as u64,
+            },
+        }
+    }
+}
+impl InvokeContext for MockInvokeContext {
+    fn push(&mut self, _key: &Pubkey) -> Result<(), InstructionError> {
+        Ok(())
+    }
+    fn pop(&mut self) {}
+    fn verify_and_update(
+        &mut self,
+        _message: &Message,
+        _instruction: &CompiledInstruction,
+        _accounts: &[Rc<RefCell<Account>>],
+    ) -> Result<(), InstructionError> {
+        Ok(())
+    }
+    fn get_caller(&self) -> Result<&Pubkey, InstructionError> {
+        Ok(&self.key)
+    }
+    fn get_programs(&self) -> &[(Pubkey, ProcessInstructionWithContext)] {
+        &[]
+    }
+    fn get_logger(&self) -> Rc<RefCell<dyn Logger>> {
+        Rc::new(RefCell::new(self.logger.clone()))
+    }
+    fn get_compute_budget(&self) -> &ComputeBudget {
+        &self.compute_budget
+    }
+    fn get_compute_meter(&self) -> Rc<RefCell<dyn ComputeMeter>> {
+        Rc::new(RefCell::new(self.compute_meter.clone()))
+    }
+    fn add_executor(&mut self, _pubkey: &Pubkey, _executor: Arc<dyn Executor>) {}
+    fn get_executor(&mut self, _pubkey: &Pubkey) -> Option<Arc<dyn Executor>> {
+        None
+    }
+    fn record_instruction(&self, _instruction: &Instruction) {}
+    fn is_feature_active(&self, _feature_id: &Pubkey) -> bool {
+        true
+    }
+}