builtins consume statically defined units at beginning of process_ins…

…truction()

programs/address-lookup-table/src/processor.rs

@@ -19,6 +19,13 @@ use {
 };
 
 pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), InstructionError> {
+    // Consume compute units if feature `native_programs_consume_cu` is activated,
+    if invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id())
+    {
+        invoke_context.consume_checked(750)?;
+    }
     let transaction_context = &invoke_context.transaction_context;
     let instruction_context = transaction_context.get_current_instruction_context()?;
     let instruction_data = instruction_context.get_instruction_data();

programs/bpf_loader/src/lib.rs

@@ -46,7 +46,7 @@ use {
             disable_deploy_of_alloc_free_syscall, enable_bpf_loader_extend_program_ix,
             enable_bpf_loader_set_authority_checked_ix, enable_program_redeployment_cooldown,
             limit_max_instruction_trace_length, remove_bpf_loader_incorrect_program_id,
-            round_up_heap_size, FeatureSet,
+            round_up_heap_size, native_programs_consume_cu, FeatureSet,
         },
         instruction::{AccountMeta, InstructionError},
         loader_instruction::LoaderInstruction,
@@ -520,15 +520,29 @@ fn process_instruction_common(
     let program_account =
         instruction_context.try_borrow_last_program_account(transaction_context)?;
 
+    // Consume compute units if feature `native_programs_consume_cu` is activated
+    let native_programs_consume_cu = invoke_context
+        .feature_set
+        .is_active(&native_programs_consume_cu::id());
+
     // Program Management Instruction
     if native_loader::check_id(program_account.get_owner()) {
         drop(program_account);
         let program_id = instruction_context.get_last_program_key(transaction_context)?;
         return if bpf_loader_upgradeable::check_id(program_id) {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(2_370)?;
+            }
             process_loader_upgradeable_instruction(invoke_context, use_jit)
         } else if bpf_loader::check_id(program_id) {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(570)?;
+            }
             process_loader_instruction(invoke_context, use_jit)
         } else if bpf_loader_deprecated::check_id(program_id) {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(1_140)?;
+            }
             ic_logger_msg!(log_collector, "Deprecated loader is no longer supported");
             Err(InstructionError::UnsupportedProgramId)
         } else {

programs/compute-budget/src/lib.rs

@@ -1,9 +1,17 @@
 use {
     solana_program_runtime::invoke_context::InvokeContext,
-    solana_sdk::instruction::InstructionError,
+    solana_sdk::{feature_set, instruction::InstructionError},
 };
 
-pub fn process_instruction(_invoke_context: &mut InvokeContext) -> Result<(), InstructionError> {
+pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), InstructionError> {
+    // Consume compute units if feature `native_programs_consume_cu` is activated,
+    if invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id())
+    {
+        invoke_context.consume_checked(150)?;
+    }
+
     // Do nothing, compute budget instructions handled by the runtime
     Ok(())
 }

programs/config/src/config_processor.rs

@@ -16,6 +16,14 @@ pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), Ins
     let instruction_context = transaction_context.get_current_instruction_context()?;
     let data = instruction_context.get_instruction_data();
 
+    // Consume compute units if feature `native_programs_consume_cu` is activated,
+    if invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id())
+    {
+        invoke_context.consume_checked(450)?;
+    }
+
     let key_list: ConfigKeys = limited_deserialize(data)?;
     let config_account_key = transaction_context.get_key_of_account_at_index(
         instruction_context.get_index_of_instruction_account_in_transaction(0)?,

programs/stake/src/stake_instruction.rs

@@ -58,6 +58,14 @@ pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), Ins
 
     trace!("process_instruction: {:?}", data);
 
+    // Consume compute units if feature `native_programs_consume_cu` is activated,
+    if invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id())
+    {
+        invoke_context.consume_checked(750)?;
+    }
+
     let get_stake_account = || {
         let me = instruction_context.try_borrow_instruction_account(transaction_context, 0)?;
         if *me.get_owner() != id() {

programs/vote/src/vote_processor.rs

@@ -62,6 +62,16 @@ pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), Ins
 
     trace!("process_instruction: {:?}", data);
 
+    // Consume compute units if feature `native_programs_consume_cu` is activated,
+    // Citing `runtime/src/block_cost_limit.rs`, vote has statically defined 2_100
+    // units; can consume based on instructions in the future like `bpf_loader` does.
+    if invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id())
+    {
+        invoke_context.consume_checked(2_100)?;
+    }
+
     let mut me = instruction_context.try_borrow_instruction_account(transaction_context, 0)?;
     if *me.get_owner() != id() {
         return Err(InstructionError::InvalidAccountOwner);

programs/zk-token-proof/src/lib.rs

@@ -4,6 +4,7 @@ use {
     bytemuck::Pod,
     solana_program_runtime::{ic_msg, invoke_context::InvokeContext},
     solana_sdk::{
+        feature_set,
         instruction::{InstructionError, TRANSACTION_LEVEL_STACK_HEIGHT},
         system_program,
     },
@@ -119,12 +120,10 @@ pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), Ins
         return Err(InstructionError::UnsupportedProgramId);
     }
 
-    // Consume compute units since proof verification is an expensive operation
-    {
-        // TODO: Tune the number of units consumed.  The current value is just a rough estimate
-        invoke_context.consume_checked(100_000)?;
-    }
-
+    // Consume compute units if feature `native_programs_consume_cu` is activated
+    let native_programs_consume_cu = invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id());
     let transaction_context = &invoke_context.transaction_context;
     let instruction_context = transaction_context.get_current_instruction_context()?;
     let instruction_data = instruction_context.get_instruction_data();
@@ -137,28 +136,46 @@ pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), Ins
             process_close_proof_context(invoke_context)
         }
         ProofInstruction::VerifyCloseAccount => {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(6_012)?;
+            }
             ic_msg!(invoke_context, "VerifyCloseAccount");
             process_verify_proof::<CloseAccountData, CloseAccountProofContext>(invoke_context)
         }
         ProofInstruction::VerifyWithdraw => {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(112_454)?;
+            }
             ic_msg!(invoke_context, "VerifyWithdraw");
             process_verify_proof::<WithdrawData, WithdrawProofContext>(invoke_context)
         }
         ProofInstruction::VerifyWithdrawWithheldTokens => {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(7_943)?;
+            }
             ic_msg!(invoke_context, "VerifyWithdrawWithheldTokens");
             process_verify_proof::<WithdrawWithheldTokensData, WithdrawWithheldTokensProofContext>(
                 invoke_context,
             )
         }
         ProofInstruction::VerifyTransfer => {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(219_290)?;
+            }
             ic_msg!(invoke_context, "VerifyTransfer");
             process_verify_proof::<TransferData, TransferProofContext>(invoke_context)
         }
         ProofInstruction::VerifyTransferWithFee => {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(407_121)?;
+            }
             ic_msg!(invoke_context, "VerifyTransferWithFee");
             process_verify_proof::<TransferWithFeeData, TransferWithFeeProofContext>(invoke_context)
         }
         ProofInstruction::VerifyPubkeyValidity => {
+            if native_programs_consume_cu {
+                invoke_context.consume_checked(2_619)?;
+            }
             ic_msg!(invoke_context, "VerifyPubkeyValidity");
             process_verify_proof::<PubkeyValidityData, PubkeyValidityProofContext>(invoke_context)
         }

runtime/src/system_instruction_processor.rs

@@ -323,6 +323,14 @@ pub fn process_instruction(invoke_context: &mut InvokeContext) -> Result<(), Ins
 
     trace!("process_instruction: {:?}", instruction);
 
+    // Consume compute units if feature `native_programs_consume_cu` is activated,
+    if invoke_context
+        .feature_set
+        .is_active(&feature_set::native_programs_consume_cu::id())
+    {
+        invoke_context.consume_checked(150)?;
+    }
+
     let signers = instruction_context.get_signers(transaction_context)?;
     match instruction {
         SystemInstruction::CreateAccount {