SIMD-0339: Increase CPI Account Infos Limit

compute-budget/src/compute_budget.rs

@@ -128,10 +128,10 @@ impl Default for ComputeBudget {
 }
 
 impl ComputeBudget {
-    pub fn new_with_defaults(simd_0268_active: bool) -> Self {
+    pub fn new_with_defaults(simd_0268_active: bool, simd_0339_active: bool) -> Self {
         Self::from_budget_and_cost(
             &SVMTransactionExecutionBudget::new_with_defaults(simd_0268_active),
-            &SVMTransactionExecutionCost::default(),
+            &SVMTransactionExecutionCost::new_with_defaults(simd_0339_active),
         )
     }
 

feature-set/src/lib.rs

@@ -159,6 +159,8 @@ impl FeatureSet {
             raise_cpi_nesting_limit_to_8: self.is_active(&raise_cpi_nesting_limit_to_8::id()),
             provide_instruction_data_offset_in_vm_r2: self
                 .is_active(&provide_instruction_data_offset_in_vm_r2::id()),
+            increase_cpi_account_info_limit: self.is_active(&increase_cpi_account_info_limit::id()),
+
         }
     }
 }
@@ -1145,6 +1147,10 @@ pub mod discard_unexpected_data_complete_shreds {
     solana_pubkey::declare_id!("8MhfKhoZEoiySpVe248bDkisyEcBA7JQLyUS94xoTSqN");
 }
 
+pub mod increase_cpi_account_info_limit {
+    solana_pubkey::declare_id!("7wM2pdjwmSXviEdsorpcBY3T4YWUPQXDMepZudub7nGQ"); // Placeholder ID HAVE TO CHANGE BEFORE USE
+}
+
 pub static FEATURE_NAMES: LazyLock<AHashMap<Pubkey, &'static str>> = LazyLock::new(|| {
     [
         (secp256k1_program_enabled::id(), "secp256k1 program"),
@@ -2070,7 +2076,12 @@ pub static FEATURE_NAMES: LazyLock<AHashMap<Pubkey, &'static str>> = LazyLock::n
             discard_unexpected_data_complete_shreds::id(),
             "SIMD-0337: Markers for Alpenglow Fast Leader Handover, DATA_COMPLETE_SHRED placement \
              rules",
-        ), /*************** ADD NEW FEATURES HERE ***************/
+        ),
+        (
+            increase_cpi_account_info_limit::id(),
+            "SIMD-0339: increase CPI info account limit",
+        ),
+        /*************** ADD NEW FEATURES HERE ***************/
     ]
     .iter()
     .cloned()

program-runtime/src/cpi.rs

@@ -114,6 +114,9 @@ struct SolSignerSeedsC {
 
 /// Maximum number of account info structs that can be used in a single CPI invocation
 const MAX_CPI_ACCOUNT_INFOS: usize = 128;
+/// Maximum number of account info structs that can be used in a single CPI invocation with SIMD-0339 active
+const MAX_CPI_ACCOUNT_INFOS_SIMD_0339: usize = 255;
+
 
 /// Check that an account info pointer field points to the expected address
 fn check_account_info_pointer(
@@ -159,7 +162,12 @@ fn check_account_infos(
 ) -> Result<(), Error> {
     let max_cpi_account_infos = if invoke_context
         .get_feature_set()
-        .increase_tx_account_lock_limit
+        .increase_cpi_account_info_limit
+    {
+        MAX_CPI_ACCOUNT_INFOS_SIMD_0339
+    } else if invoke_context
+            .get_feature_set()
+            .increase_tx_account_lock_limit
     {
         MAX_CPI_ACCOUNT_INFOS
     } else {
@@ -536,6 +544,20 @@ pub fn translate_instruction_rust(
 
     check_instruction_size(account_metas.len(), data.len())?;
 
+    if invoke_context.get_feature_set().increase_cpi_account_info_limit{
+        // Each account meta is 34 bytes (32 for pubkey, 1 for is_signer, 1 for is_writable)
+        let account_meta_bytes = account_metas
+            .len()
+            .saturating_mul(size_of::<AccountMeta>()); 
+
+        consume_compute_meter(
+        invoke_context,
+        (account_meta_bytes as u64)
+            .checked_div(invoke_context.get_execution_cost().cpi_bytes_per_unit)
+            .unwrap_or(u64::MAX),
+    )?;
+    }
+
     consume_compute_meter(
         invoke_context,
         (data.len() as u64)
@@ -580,6 +602,22 @@ pub fn translate_accounts_rust<'a>(
         check_aligned,
     )?;
 
+    if invoke_context.get_feature_set().increase_cpi_account_info_limit{
+        //std::mem::size_of::<AccountInfo>() returns 48 bytes, which contains references to the 2 Pubkeys of owner and key,
+        //but we need the full size here so, need to add (32 + 32) bytes for Pubkey types and account for 8 + 8 bytes already existing for refence types.
+        //Hence adding 32 here due to 5 bytes being the padding and 11 bytes being the other data, see SIMD-0339 for calculations.
+         let account_infos_bytes = account_infos
+            .len()
+            .saturating_mul(std::mem::size_of::<AccountInfo>().saturating_add(32));
+
+        consume_compute_meter(
+        invoke_context,
+        (account_infos_bytes as u64)
+            .checked_div(invoke_context.get_execution_cost().cpi_bytes_per_unit)
+            .unwrap_or(u64::MAX),
+    )?;
+    }
+
     translate_accounts_common(
         &account_info_keys,
         account_infos,
@@ -655,6 +693,19 @@ pub fn translate_instruction_c(
 
     check_instruction_size(ix_c.accounts_len as usize, data.len())?;
 
+    if invoke_context.get_feature_set().increase_cpi_account_info_limit{
+        // Each account meta is 34 bytes (32 for pubkey, 1 for is_signer, 1 for is_writable)
+        let account_meta_bytes = ix_c.accounts_len 
+            .saturating_mul(34); 
+
+        consume_compute_meter(
+        invoke_context,
+        (account_meta_bytes as u64)
+            .checked_div(invoke_context.get_execution_cost().cpi_bytes_per_unit)
+            .unwrap_or(u64::MAX),
+    )?;
+    }
+
     consume_compute_meter(
         invoke_context,
         (data.len() as u64)
@@ -705,6 +756,20 @@ pub fn translate_accounts_c<'a>(
         check_aligned,
     )?;
 
+     if invoke_context.get_feature_set().increase_cpi_account_info_limit{
+        //sizeof(AccountInfo) is 80 bytes
+         let account_infos_bytes = account_infos
+            .len()
+            .saturating_mul(80);
+
+        consume_compute_meter(
+        invoke_context,
+        (account_infos_bytes as u64)
+            .checked_div(invoke_context.get_execution_cost().cpi_bytes_per_unit)
+            .unwrap_or(u64::MAX),
+    )?;
+    }
+
     translate_accounts_common(
         &account_info_keys,
         account_infos,
@@ -776,8 +841,8 @@ pub fn cpi_common<S: SyscallInvokeSigned>(
     // changes so the callee can see them.
     consume_compute_meter(
         invoke_context,
-        invoke_context.get_execution_cost().invoke_units,
-    )?;
+        invoke_context.get_execution_cost().invoke_units
+    )?; 
     if let Some(execute_time) = invoke_context.execute_time.as_mut() {
         execute_time.stop();
         invoke_context.timings.execute_us += execute_time.as_us();

program-runtime/src/execution_budget.rs

@@ -17,6 +17,19 @@ fn get_max_instruction_stack_depth(simd_0268_active: bool) -> usize {
     }
 }
 
+//Default CPI invocation cost
+pub const DEFAULT_INVOCATION_COST: u64 = 1000;
+//CPI Invocation cost with SIMD-0339 active
+pub const INVOKE_UNITS_COST_SIMD_0339: u64 = 946;
+
+fn get_invoke_unit_cost(simd_0339_active: bool) -> u64 {
+    if simd_0339_active {
+        INVOKE_UNITS_COST_SIMD_0339
+    } else {
+        DEFAULT_INVOCATION_COST
+    }
+}
+
 /// Max call depth. This is the maximum nesting of SBF to SBF call that can happen within a program.
 pub const MAX_CALL_DEPTH: usize = 64;
 
@@ -176,10 +189,16 @@ pub struct SVMTransactionExecutionCost {
 
 impl Default for SVMTransactionExecutionCost {
     fn default() -> Self {
-        Self {
+        Self::new_with_defaults(/* simd_0339_active */ false)
+    }
+}
+
+impl SVMTransactionExecutionCost {
+    pub fn new_with_defaults(simd_0339_active: bool) -> Self {
+        SVMTransactionExecutionCost {
             log_64_units: 100,
             create_program_address_units: 1500,
-            invoke_units: 1000,
+            invoke_units: get_invoke_unit_cost(simd_0339_active),
             sha256_base_cost: 85,
             sha256_byte_cost: 1,
             log_pubkey_units: 100,
@@ -216,9 +235,7 @@ impl Default for SVMTransactionExecutionCost {
             alt_bn128_g2_decompress: 13610,
         }
     }
-}
 
-impl SVMTransactionExecutionCost {
     /// Returns cost of the Poseidon hash function for the given number of
     /// inputs is determined by the following quadratic function:
     ///

program-runtime/src/invoke_context.rs

@@ -831,7 +831,9 @@ macro_rules! with_mock_invoke_context_with_feature_set {
             environment_config,
             Some(LogCollector::new_ref()),
             compute_budget,
-            SVMTransactionExecutionCost::default(),
+            SVMTransactionExecutionCost::new_with_defaults(
+                $feature_set.increase_cpi_account_info_limit,
+            ),
         );
     };
 }

program-test/src/lib.rs

@@ -4,7 +4,7 @@
 // Export tokio for test clients
 pub use tokio;
 use {
-    agave_feature_set::{raise_cpi_nesting_limit_to_8, FEATURE_NAMES},
+    agave_feature_set::{raise_cpi_nesting_limit_to_8, increase_cpi_account_info_limit, FEATURE_NAMES},
     async_trait::async_trait,
     base64::{prelude::BASE64_STANDARD, Engine},
     chrono_humanize::{Accuracy, HumanTime, Tense},
@@ -850,6 +850,9 @@ impl ProgramTest {
                         genesis_config
                             .accounts
                             .contains_key(&raise_cpi_nesting_limit_to_8::id()),
+                        genesis_config
+                            .accounts
+                            .contains_key(&increase_cpi_account_info_limit::id()),
                     )
                 }),
                 transaction_account_lock_limit: self.transaction_account_lock_limit,

programs/sbf/c/src/invoke/invoke.c

@@ -31,7 +31,7 @@ static const uint8_t ADD_LAMPORTS = 18;
 static const uint8_t TEST_RETURN_DATA_TOO_LARGE = 19;
 static const uint8_t TEST_DUPLICATE_PRIVILEGE_ESCALATION_SIGNER = 20;
 static const uint8_t TEST_DUPLICATE_PRIVILEGE_ESCALATION_WRITABLE = 21;
-static const uint8_t TEST_MAX_ACCOUNT_INFOS_EXCEEDED = 22;
+static const uint8_t TEST_MAX_ACCOUNT_INFOS_EXCEEDED_INCREASE_CPI_INFO = 22;
 // TEST_CPI_INVALID_* must match the definitions in
 // https://github.com/solana-labs/solana/blob/master/programs/sbf/rust/invoke/src/instructions.rs
 static const uint8_t TEST_CPI_INVALID_KEY_POINTER = 35;
@@ -42,6 +42,11 @@ static const uint8_t TEST_WRITE_ACCOUNT = 40;
 static const uint8_t TEST_ACCOUNT_INFO_IN_ACCOUNT = 43;
 static const uint8_t TEST_NESTED_INVOKE_SIMD_0268_OK = 46;
 static const uint8_t TEST_NESTED_INVOKE_SIMD_0268_TOO_DEEP = 47;
+static const uint8_t TEST_MAX_ACCOUNT_INFOS_SIMD_0339_OK = 48;
+static const uint8_t TEST_MAX_ACCOUNT_INFOS_SIMD_0339_EXCEEDED = 49;
+static const uint8_t TEST_MAX_ACCOUNT_INFOS_OK = 50;
+static const uint8_t TEST_MAX_ACCOUNT_INFOS_OK_INCREASE_CPI_INFO = 51;
+static const uint8_t TEST_MAX_ACCOUNT_INFOS_EXCEEDED = 52;
 
 static const int MINT_INDEX = 0;
 static const int ARGUMENT_INDEX = 1;
@@ -548,9 +553,66 @@ extern uint64_t entrypoint(const uint8_t *input) {
 
     break;
   }
+  case TEST_MAX_ACCOUNT_INFOS_OK: {
+    sol_log("Test max allowed account infos");
+    SolAccountMeta arguments[] = {};
+    uint64_t account_infos_len = 64;
+    SolAccountInfo *account_infos = sol_calloc(account_infos_len, sizeof(SolAccountInfo));
+    sol_assert(0 != account_infos);
+    for (uint64_t i = 0; i < account_infos_len; i++) {
+      account_infos[i] = accounts[0]; 
+    }
+    uint8_t data[] = {};
+    const SolInstruction instruction = {accounts[INVOKED_PROGRAM_INDEX].key,
+                                        arguments, SOL_ARRAY_SIZE(arguments),
+                                        data, SOL_ARRAY_SIZE(data)};
+    const SolSignerSeeds signers_seeds[] = {};
+    sol_assert(SUCCESS == sol_invoke_signed(
+                              &instruction, account_infos, account_infos_len,
+                              signers_seeds, SOL_ARRAY_SIZE(signers_seeds)));
+
+    break;
+  }
   case TEST_MAX_ACCOUNT_INFOS_EXCEEDED: {
     sol_log("Test max account infos exceeded");
     SolAccountMeta arguments[] = {};
+    uint64_t account_infos_len = 65;
+    SolAccountInfo *account_infos = sol_calloc(account_infos_len, sizeof(SolAccountInfo));
+    sol_assert(0 != account_infos);
+    uint8_t data[] = {};
+    const SolInstruction instruction = {accounts[INVOKED_PROGRAM_INDEX].key,
+                                        arguments, SOL_ARRAY_SIZE(arguments),
+                                        data, SOL_ARRAY_SIZE(data)};
+    const SolSignerSeeds signers_seeds[] = {};
+    sol_assert(SUCCESS == sol_invoke_signed(
+                              &instruction, account_infos, account_infos_len,
+                              signers_seeds, SOL_ARRAY_SIZE(signers_seeds)));
+
+    break;
+  }
+  case TEST_MAX_ACCOUNT_INFOS_OK_INCREASE_CPI_INFO: {
+    sol_log("Test max account infos allowed with increase cpi info");
+    SolAccountMeta arguments[] = {};
+    uint64_t account_infos_len = MAX_CPI_ACCOUNT_INFOS;
+    SolAccountInfo *account_infos = sol_calloc(account_infos_len, sizeof(SolAccountInfo));
+    sol_assert(0 != account_infos);
+     for (uint64_t i = 0; i < account_infos_len; i++) {
+      account_infos[i] = accounts[0]; 
+    }
+    uint8_t data[] = {};
+    const SolInstruction instruction = {accounts[INVOKED_PROGRAM_INDEX].key,
+                                        arguments, SOL_ARRAY_SIZE(arguments),
+                                        data, SOL_ARRAY_SIZE(data)};
+    const SolSignerSeeds signers_seeds[] = {};
+    sol_assert(SUCCESS == sol_invoke_signed(
+                              &instruction, account_infos, account_infos_len,
+                              signers_seeds, SOL_ARRAY_SIZE(signers_seeds)));
+
+    break;
+  }
+  case TEST_MAX_ACCOUNT_INFOS_EXCEEDED_INCREASE_CPI_INFO: {
+    sol_log("Test max account infos exceeded with increase cpi info");
+    SolAccountMeta arguments[] = {};
     uint64_t account_infos_len = MAX_CPI_ACCOUNT_INFOS + 1;
     SolAccountInfo *account_infos = sol_calloc(account_infos_len, sizeof(SolAccountInfo));
     sol_assert(0 != account_infos);
@@ -565,6 +627,44 @@ extern uint64_t entrypoint(const uint8_t *input) {
 
     break;
   }
+  case TEST_MAX_ACCOUNT_INFOS_SIMD_0339_OK: {
+    sol_log("Test max account infos allowed with SIMD-0339");
+    SolAccountMeta arguments[] = {};
+    uint64_t account_infos_len = 255;
+    SolAccountInfo *account_infos = sol_calloc(account_infos_len, sizeof(SolAccountInfo));
+    sol_assert(0 != account_infos);
+
+    for (uint64_t i = 0; i < account_infos_len; i++) {
+      account_infos[i] = accounts[0]; 
+    }
+    uint8_t data[] = {};
+    const SolInstruction instruction = {accounts[INVOKED_PROGRAM_INDEX].key,
+                                        arguments, SOL_ARRAY_SIZE(arguments),
+                                        data, SOL_ARRAY_SIZE(data)};
+    const SolSignerSeeds signers_seeds[] = {};
+    sol_assert(SUCCESS == sol_invoke_signed(
+                              &instruction, account_infos, account_infos_len,
+                              signers_seeds, SOL_ARRAY_SIZE(signers_seeds)));
+
+    break;
+  }
+  case TEST_MAX_ACCOUNT_INFOS_SIMD_0339_EXCEEDED: {
+    sol_log("Test max account infos exceeded with SIMD-0339");
+    SolAccountMeta arguments[] = {};
+    uint64_t account_infos_len = 256;
+    SolAccountInfo *account_infos = sol_calloc(account_infos_len, sizeof(SolAccountInfo));
+    sol_assert(0 != account_infos);
+    uint8_t data[] = {};
+    const SolInstruction instruction = {accounts[INVOKED_PROGRAM_INDEX].key,
+                                        arguments, SOL_ARRAY_SIZE(arguments),
+                                        data, SOL_ARRAY_SIZE(data)};
+    const SolSignerSeeds signers_seeds[] = {};
+    sol_assert(SUCCESS == sol_invoke_signed(
+                              &instruction, account_infos, account_infos_len,
+                              signers_seeds, SOL_ARRAY_SIZE(signers_seeds)));
+
+    break;
+  }
   case TEST_RETURN_ERROR: {
     sol_log("Test return error");
     SolAccountMeta arguments[] = {{accounts[ARGUMENT_INDEX].key, false, true}};