Test recursion for all priority IXs

Author: deanmlittle

program/src/entrypoint.rs

@@ -3,6 +3,7 @@ use pinocchio::{
     account_info::AccountInfo, default_panic_handler, no_allocator, program_entrypoint,
     program_error::ProgramError, pubkey::Pubkey, ProgramResult,
 };
+use pinocchio_pubkey::pubkey;
 
 use crate::processor::*;
 
@@ -34,6 +35,7 @@ pub fn process_instruction(
     accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> ProgramResult {
+
     let (discriminator, instruction_data) = instruction_data
         .split_first()
         .ok_or(ProgramError::InvalidInstructionData)?;

program/src/lib.rs

@@ -2,5 +2,7 @@
 
 #![no_std]
 
+#![feature(split_at_checked)]
+
 mod entrypoint;
 mod processor;

program/src/processor/batch.rs

@@ -1,47 +1,8 @@
-use core::mem::size_of;
 use pinocchio::{
-    account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+    account_info::AccountInfo, program_error::ProgramError, ProgramResult
 };
 
-use crate::processor::{
-    process_close_account, process_initialize_account3, process_initialize_mint,
-    process_initialize_mint2, process_mint_to, process_transfer,
-};
-
-macro_rules! map_accounts {
-    // For 1 account
-    ($accounts:expr, $instruction_data:expr, 1) => {{
-        let (account_idx, rest) = $instruction_data
-            .split_first()
-            .ok_or(ProgramError::InvalidInstructionData)?;
-        *$instruction_data = rest;
-        let batch_accounts = [$accounts[*account_idx as usize].clone()];
-        batch_accounts
-    }};
-
-    // For 2 accounts
-    ($accounts:expr, $instruction_data:expr, 2) => {{
-        let (account_indices, rest) = $instruction_data.split_at(2);
-        *$instruction_data = rest;
-        let batch_accounts = [
-            $accounts[account_indices[0] as usize].clone(),
-            $accounts[account_indices[1] as usize].clone(),
-        ];
-        batch_accounts
-    }};
-
-    // For 3 accounts
-    ($accounts:expr, $instruction_data:expr, 3) => {{
-        let (account_indices, rest) = $instruction_data.split_at(3);
-        *$instruction_data = rest;
-        let batch_accounts = [
-            $accounts[account_indices[0] as usize].clone(),
-            $accounts[account_indices[1] as usize].clone(),
-            $accounts[account_indices[2] as usize].clone(),
-        ];
-        batch_accounts
-    }};
-}
+use crate::entrypoint::process_instruction;
 
 #[inline(always)]
 pub fn process_batch(accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult {
@@ -50,77 +11,18 @@ pub fn process_batch(accounts: &[AccountInfo], instruction_data: &[u8]) -> Progr
         .split_first()
         .ok_or(ProgramError::InvalidInstructionData)?;
 
-    let mut discriminator;
+    let mut lengths: &[u8];
+    let mut accounts = accounts;
+    let mut current_accounts: &[AccountInfo];
+    let mut current_instruction_data: &[u8];
+
     for _ in 0..*counter {
-        (discriminator, instruction_data) = instruction_data
-            .split_first()
+        (lengths, instruction_data) = instruction_data
+            .split_at_checked(2)
             .ok_or(ProgramError::InvalidInstructionData)?;
-        match discriminator {
-            // 0 - InitializeMint
-            0 => {
-                #[cfg(feature = "logging")]
-                pinocchio::msg!("Batch Instruction: InitializeMint");
-
-                let batch_accounts = map_accounts!(accounts, &mut instruction_data, 2);
-                process_initialize_mint(&batch_accounts, instruction_data, true)?;
-                if instruction_data[size_of::<(u8, Pubkey)>()] == 0 {
-                    instruction_data = &instruction_data[size_of::<(u8, Pubkey, u8)>()..];
-                } else {
-                    instruction_data = &instruction_data[size_of::<(u8, Pubkey, u8, Pubkey)>()..];
-                }
-            }
-            // 3 - Transfer
-            3 => {
-                #[cfg(feature = "logging")]
-                pinocchio::msg!("Batch Instruction: Transfer");
-
-                let batch_accounts = map_accounts!(accounts, &mut instruction_data, 3);
-                process_transfer(&batch_accounts, instruction_data)?;
-                instruction_data = &instruction_data[size_of::<u64>()..];
-            }
-            // 7 - MintTo
-            7 => {
-                #[cfg(feature = "logging")]
-                pinocchio::msg!("Batch Instruction: MintTo");
-
-                let batch_accounts = map_accounts!(accounts, &mut instruction_data, 3);
-                process_mint_to(&batch_accounts, instruction_data)?;
-                instruction_data = &instruction_data[size_of::<u64>()..];
-            }
-            // 9 - CloseAccount
-            9 => {
-                #[cfg(feature = "logging")]
-                pinocchio::msg!("Batch Instruction: CloseAccount");
-
-                let batch_accounts = map_accounts!(accounts, &mut instruction_data, 2);
-                process_close_account(&batch_accounts)?;
-            }
-            // 18 - InitializeAccount3
-            18 => {
-                #[cfg(feature = "logging")]
-                pinocchio::msg!("Batch Instruction: InitializeAccount3");
-
-                let batch_accounts = map_accounts!(accounts, &mut instruction_data, 3);
-                process_initialize_account3(&batch_accounts, instruction_data)?;
-                instruction_data = &instruction_data[size_of::<Pubkey>()..];
-            }
-            // 20 - InitializeMint2
-            20 => {
-                #[cfg(feature = "logging")]
-                pinocchio::msg!("Instruction: InitializeMint2");
-
-                let batch_accounts = map_accounts!(accounts, &mut instruction_data, 1);
-                process_initialize_mint2(&batch_accounts, instruction_data)?;
-                if instruction_data[size_of::<(u8, Pubkey)>()] == 0 {
-                    instruction_data = &instruction_data[size_of::<(u8, Pubkey, u8)>()..];
-                } else {
-                    instruction_data = &instruction_data[size_of::<(u8, Pubkey, u8, Pubkey)>()..];
-                }
-            }
-            _ => {
-                return Err(ProgramError::InvalidInstructionData);
-            }
-        }
+        (current_accounts, accounts) = accounts.split_at_checked(lengths[0].into()).ok_or(ProgramError::InvalidInstructionData)?;
+        (current_instruction_data, instruction_data) = instruction_data.split_at_checked(lengths[1].into()).ok_or(ProgramError::InvalidInstructionData)?;
+        process_instruction(&token_interface::program::ID, current_accounts, current_instruction_data)?;
     }
     Ok(())
-}
+}

program/src/processor/get_account_data_size.rs

@@ -10,7 +10,7 @@ use super::check_account_owner;
 
 #[inline(always)]
 pub fn process_get_account_data_size(accounts: &[AccountInfo]) -> ProgramResult {
-    let [mint_info, _remaning @ ..] = accounts else {
+    let [mint_info, _remaining @ ..] = accounts else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 

program/src/processor/revoke.rs

@@ -8,7 +8,7 @@ use super::validate_owner;
 
 #[inline(always)]
 pub fn process_revoke(accounts: &[AccountInfo], _instruction_data: &[u8]) -> ProgramResult {
-    let [source_account_info, owner_info, remaning @ ..] = accounts else {
+    let [source_account_info, owner_info, remaining @ ..] = accounts else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 
@@ -19,7 +19,7 @@ pub fn process_revoke(accounts: &[AccountInfo], _instruction_data: &[u8]) -> Pro
         return Err(TokenError::AccountFrozen.into());
     }
 
-    validate_owner(&source_account.owner, owner_info, remaning)?;
+    validate_owner(&source_account.owner, owner_info, remaining)?;
 
     source_account.clear_delegate();
     source_account.set_delegated_amount(0);

program/src/processor/set_authority.rs

@@ -22,7 +22,7 @@ pub fn process_set_authority(accounts: &[AccountInfo], instruction_data: &[u8])
 
     // Validates the accounts.
 
-    let [account_info, authority_info, remaning @ ..] = accounts else {
+    let [account_info, authority_info, remaining @ ..] = accounts else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 
@@ -35,7 +35,7 @@ pub fn process_set_authority(accounts: &[AccountInfo], instruction_data: &[u8])
 
         match authority_type {
             AuthorityType::AccountOwner => {
-                validate_owner(&account.owner, authority_info, remaning)?;
+                validate_owner(&account.owner, authority_info, remaining)?;
 
                 if let Some(authority) = new_authority {
                     account.owner = *authority;
@@ -52,7 +52,7 @@ pub fn process_set_authority(accounts: &[AccountInfo], instruction_data: &[u8])
             }
             AuthorityType::CloseAccount => {
                 let authority = account.close_authority().unwrap_or(&account.owner);
-                validate_owner(authority, authority_info, remaning)?;
+                validate_owner(authority, authority_info, remaining)?;
 
                 if let Some(authority) = new_authority {
                     account.set_close_authority(authority);
@@ -73,7 +73,7 @@ pub fn process_set_authority(accounts: &[AccountInfo], instruction_data: &[u8])
                 // mint_authority.
                 let mint_authority = mint.mint_authority().ok_or(TokenError::FixedSupply)?;
 
-                validate_owner(mint_authority, authority_info, remaning)?;
+                validate_owner(mint_authority, authority_info, remaining)?;
 
                 if let Some(authority) = new_authority {
                     mint.set_mint_authority(authority);
@@ -88,7 +88,7 @@ pub fn process_set_authority(accounts: &[AccountInfo], instruction_data: &[u8])
                     .freeze_authority()
                     .ok_or(TokenError::MintCannotFreeze)?;
 
-                validate_owner(freeze_authority, authority_info, remaning)?;
+                validate_owner(freeze_authority, authority_info, remaining)?;
 
                 if let Some(authority) = new_authority {
                     mint.set_freeze_authority(authority);

program/src/processor/shared/approve.rs

@@ -17,7 +17,7 @@ pub fn process_approve(
 
     let (source_account_info, expected_mint_info, delegate_info, owner_info, remaining) =
         if let Some(expected_decimals) = expected_decimals {
-            let [source_account_info, expected_mint_info, delegate_info, owner_info, remaning @ ..] =
+            let [source_account_info, expected_mint_info, delegate_info, owner_info, remaining @ ..] =
                 accounts
             else {
                 return Err(ProgramError::NotEnoughAccountKeys);
@@ -28,18 +28,18 @@ pub fn process_approve(
                 Some((expected_mint_info, expected_decimals)),
                 delegate_info,
                 owner_info,
-                remaning,
+                remaining,
             )
         } else {
-            let [source_account_info, delegate_info, owner_info, remaning @ ..] = accounts else {
+            let [source_account_info, delegate_info, owner_info, remaining @ ..] = accounts else {
                 return Err(ProgramError::NotEnoughAccountKeys);
             };
             (
                 source_account_info,
                 None,
                 delegate_info,
                 owner_info,
-                remaning,
+                remaining,
             )
         };
 

program/src/processor/shared/initialize_account.rs

@@ -24,24 +24,24 @@ pub fn process_initialize_account(
 ) -> ProgramResult {
     // Accounts expected depend on whether we have the `rent_sysvar` account or not.
 
-    let (new_account_info, mint_info, owner, remaning) = if let Some(owner) = owner {
-        let [new_account_info, mint_info, remaning @ ..] = accounts else {
+    let (new_account_info, mint_info, owner, remaining) = if let Some(owner) = owner {
+        let [new_account_info, mint_info, remaining @ ..] = accounts else {
             return Err(ProgramError::NotEnoughAccountKeys);
         };
-        (new_account_info, mint_info, owner, remaning)
+        (new_account_info, mint_info, owner, remaining)
     } else {
-        let [new_account_info, mint_info, owner_info, remaning @ ..] = accounts else {
+        let [new_account_info, mint_info, owner_info, remaining @ ..] = accounts else {
             return Err(ProgramError::NotEnoughAccountKeys);
         };
-        (new_account_info, mint_info, owner_info.key(), remaning)
+        (new_account_info, mint_info, owner_info.key(), remaining)
     };
 
     // Check rent-exempt status of the token account.
 
     let new_account_info_data_len = new_account_info.data_len();
 
     let minimum_balance = if rent_sysvar_account {
-        let rent_sysvar_info = remaning.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
+        let rent_sysvar_info = remaining.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
         let rent = unsafe { Rent::from_bytes(rent_sysvar_info.borrow_data_unchecked()) };
         rent.minimum_balance(new_account_info_data_len)
     } else {

program/src/processor/shared/transfer.rs

@@ -20,9 +20,9 @@ pub fn process_transfer(
         expected_mint_info,
         destination_account_info,
         authority_info,
-        remaning,
+        remaining,
     ) = if let Some(decimals) = expected_decimals {
-        let [source_account_info, mint_info, destination_account_info, authority_info, remaning @ ..] =
+        let [source_account_info, mint_info, destination_account_info, authority_info, remaining @ ..] =
             accounts
         else {
             return Err(ProgramError::NotEnoughAccountKeys);
@@ -32,10 +32,10 @@ pub fn process_transfer(
             Some((mint_info, decimals)),
             destination_account_info,
             authority_info,
-            remaning,
+            remaining,
         )
     } else {
-        let [source_account_info, destination_account_info, authority_info, remaning @ ..] =
+        let [source_account_info, destination_account_info, authority_info, remaining @ ..] =
             accounts
         else {
             return Err(ProgramError::NotEnoughAccountKeys);
@@ -45,7 +45,7 @@ pub fn process_transfer(
             None,
             destination_account_info,
             authority_info,
-            remaning,
+            remaining,
         )
     };
 
@@ -95,7 +95,7 @@ pub fn process_transfer(
     // Validates the authority (delegate or owner).
 
     if source_account.delegate() == Some(authority_info.key()) {
-        validate_owner(authority_info.key(), authority_info, remaning)?;
+        validate_owner(authority_info.key(), authority_info, remaining)?;
 
         let delegated_amount = source_account
             .delegated_amount()
@@ -110,7 +110,7 @@ pub fn process_transfer(
             }
         }
     } else {
-        validate_owner(&source_account.owner, authority_info, remaning)?;
+        validate_owner(&source_account.owner, authority_info, remaining)?;
     }
 
     if self_transfer || amount == 0 {