Adds CanInvoke to sys program

programs/system/src/instructions/advance_nonce_account.rs

@@ -1,10 +1,9 @@
 use pinocchio::{
-    account_info::AccountInfo,
-    instruction::{AccountMeta, Instruction, Signer},
-    program::invoke_signed,
-    ProgramResult,
+    account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey, ProgramResult,
 };
 
+use crate::CanInvoke;
+
 /// Consumes a stored nonce, replacing it with a successor.
 ///
 /// ### Accounts:
@@ -22,32 +21,27 @@ pub struct AdvanceNonceAccount<'a> {
     pub authority: &'a AccountInfo,
 }
 
-impl AdvanceNonceAccount<'_> {
-    #[inline(always)]
-    pub fn invoke(&self) -> ProgramResult {
-        self.invoke_signed(&[])
-    }
-
-    #[inline(always)]
-    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        // account metadata
-        let account_metas: [AccountMeta; 3] = [
-            AccountMeta::writable(self.account.key()),
-            AccountMeta::readonly(self.recent_blockhashes_sysvar.key()),
-            AccountMeta::readonly_signer(self.authority.key()),
-        ];
-
-        // instruction
-        let instruction = Instruction {
-            program_id: &crate::ID,
-            accounts: &account_metas,
-            data: &[4],
-        };
+const ACCOUNTS_LEN: usize = 3;
 
-        invoke_signed(
-            &instruction,
+impl CanInvoke<ACCOUNTS_LEN> for AdvanceNonceAccount<'_> {
+    fn invoke_via(
+        self,
+        invoke: impl FnOnce(
+            /* program_id: */ &Pubkey,
+            /* accounts: */ &[&AccountInfo; ACCOUNTS_LEN],
+            /* account_metas: */ &[AccountMeta],
+            /* data: */ &[u8],
+        ) -> ProgramResult,
+    ) -> ProgramResult {
+        invoke(
+            &crate::ID,
             &[self.account, self.recent_blockhashes_sysvar, self.authority],
-            signers,
+            &[
+                AccountMeta::writable(self.account.key()),
+                AccountMeta::readonly(self.recent_blockhashes_sysvar.key()),
+                AccountMeta::readonly_signer(self.authority.key()),
+            ],
+            &[4],
         )
     }
 }

programs/system/src/instructions/allocate.rs

@@ -1,10 +1,9 @@
 use pinocchio::{
-    account_info::AccountInfo,
-    instruction::{AccountMeta, Instruction, Signer},
-    program::invoke_signed,
-    ProgramResult,
+    account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey, ProgramResult,
 };
 
+use crate::CanInvoke;
+
 /// Allocate space in a (possibly new) account without funding.
 ///
 /// ### Accounts:
@@ -17,30 +16,30 @@ pub struct Allocate<'a> {
     pub space: u64,
 }
 
-impl Allocate<'_> {
-    #[inline(always)]
-    pub fn invoke(&self) -> ProgramResult {
-        self.invoke_signed(&[])
-    }
-
-    #[inline(always)]
-    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        // account metadata
-        let account_metas: [AccountMeta; 1] = [AccountMeta::writable_signer(self.account.key())];
+const ACCOUNTS_LEN: usize = 1;
 
+impl CanInvoke<ACCOUNTS_LEN> for Allocate<'_> {
+    fn invoke_via(
+        self,
+        invoke: impl FnOnce(
+            /* program_id: */ &Pubkey,
+            /* accounts: */ &[&AccountInfo; ACCOUNTS_LEN],
+            /* account_metas: */ &[AccountMeta],
+            /* data: */ &[u8],
+        ) -> ProgramResult,
+    ) -> ProgramResult {
         // instruction data
         // -  [0..4 ]: instruction discriminator
         // -  [4..12]: space
         let mut instruction_data = [0; 12];
         instruction_data[0] = 8;
         instruction_data[4..12].copy_from_slice(&self.space.to_le_bytes());
 
-        let instruction = Instruction {
-            program_id: &crate::ID,
-            accounts: &account_metas,
-            data: &instruction_data,
-        };
-
-        invoke_signed(&instruction, &[self.account], signers)
+        invoke(
+            &crate::ID,
+            &[self.account],
+            &[AccountMeta::writable_signer(self.account.key())],
+            &instruction_data,
+        )
     }
 }

programs/system/src/instructions/allocate_with_seed.rs

@@ -1,11 +1,9 @@
 use pinocchio::{
-    account_info::AccountInfo,
-    instruction::{AccountMeta, Instruction, Signer},
-    program::invoke_signed,
-    pubkey::Pubkey,
-    ProgramResult,
+    account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey, ProgramResult,
 };
 
+use crate::CanInvoke;
+
 /// Allocate space for and assign an account at an address derived
 /// from a base public key and a seed.
 ///
@@ -33,20 +31,18 @@ pub struct AllocateWithSeed<'a, 'b, 'c> {
     pub owner: &'c Pubkey,
 }
 
-impl AllocateWithSeed<'_, '_, '_> {
-    #[inline(always)]
-    pub fn invoke(&self) -> ProgramResult {
-        self.invoke_signed(&[])
-    }
-
-    #[inline(always)]
-    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        // account metadata
-        let account_metas: [AccountMeta; 2] = [
-            AccountMeta::writable(self.account.key()),
-            AccountMeta::readonly_signer(self.base.key()),
-        ];
+const ACCOUNTS_LEN: usize = 2;
 
+impl CanInvoke<ACCOUNTS_LEN> for AllocateWithSeed<'_, '_, '_> {
+    fn invoke_via(
+        self,
+        invoke: impl FnOnce(
+            /* program_id: */ &Pubkey,
+            /* accounts: */ &[&AccountInfo; ACCOUNTS_LEN],
+            /* account_metas: */ &[AccountMeta],
+            /* data: */ &[u8],
+        ) -> ProgramResult,
+    ) -> ProgramResult {
         // instruction data
         // - [0..4  ]: instruction discriminator
         // - [4..36 ]: base pubkey
@@ -64,12 +60,14 @@ impl AllocateWithSeed<'_, '_, '_> {
         instruction_data[offset..offset + 8].copy_from_slice(&self.space.to_le_bytes());
         instruction_data[offset + 8..offset + 40].copy_from_slice(self.owner.as_ref());
 
-        let instruction = Instruction {
-            program_id: &crate::ID,
-            accounts: &account_metas,
-            data: &instruction_data[..offset + 40],
-        };
-
-        invoke_signed(&instruction, &[self.account, self.base], signers)
+        invoke(
+            &crate::ID,
+            &[&self.account, &self.base],
+            &[
+                AccountMeta::writable(self.account.key()),
+                AccountMeta::readonly_signer(self.base.key()),
+            ],
+            &instruction_data[..offset + 40],
+        )
     }
 }

programs/system/src/instructions/assign.rs

@@ -1,11 +1,9 @@
 use pinocchio::{
-    account_info::AccountInfo,
-    instruction::{AccountMeta, Instruction, Signer},
-    program::invoke_signed,
-    pubkey::Pubkey,
-    ProgramResult,
+    account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey, ProgramResult,
 };
 
+use crate::CanInvoke;
+
 /// Assign account to a program
 ///
 /// ### Accounts:
@@ -18,30 +16,30 @@ pub struct Assign<'a, 'b> {
     pub owner: &'b Pubkey,
 }
 
-impl Assign<'_, '_> {
-    #[inline(always)]
-    pub fn invoke(&self) -> ProgramResult {
-        self.invoke_signed(&[])
-    }
-
-    #[inline(always)]
-    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        // account metadata
-        let account_metas: [AccountMeta; 1] = [AccountMeta::writable_signer(self.account.key())];
+const ACCOUNTS_LEN: usize = 1;
 
+impl CanInvoke<ACCOUNTS_LEN> for Assign<'_, '_> {
+    fn invoke_via(
+        self,
+        invoke: impl FnOnce(
+            /* program_id: */ &Pubkey,
+            /* accounts: */ &[&AccountInfo; ACCOUNTS_LEN],
+            /* account_metas: */ &[AccountMeta],
+            /* data: */ &[u8],
+        ) -> ProgramResult,
+    ) -> ProgramResult {
         // instruction data
         // -  [0..4 ]: instruction discriminator
         // -  [4..36]: owner pubkey
         let mut instruction_data = [0; 36];
         instruction_data[0] = 1;
         instruction_data[4..36].copy_from_slice(self.owner.as_ref());
 
-        let instruction = Instruction {
-            program_id: &crate::ID,
-            accounts: &account_metas,
-            data: &instruction_data,
-        };
-
-        invoke_signed(&instruction, &[self.account], signers)
+        invoke(
+            &crate::ID,
+            &[self.account],
+            &[AccountMeta::writable_signer(self.account.key())],
+            &instruction_data,
+        )
     }
 }

programs/system/src/instructions/assign_with_seed.rs

@@ -1,11 +1,9 @@
 use pinocchio::{
-    account_info::AccountInfo,
-    instruction::{AccountMeta, Instruction, Signer},
-    program::invoke_signed,
-    pubkey::Pubkey,
-    ProgramResult,
+    account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey, ProgramResult,
 };
 
+use crate::CanInvoke;
+
 /// Assign account to a program based on a seed.
 ///
 /// ### Accounts:
@@ -29,20 +27,18 @@ pub struct AssignWithSeed<'a, 'b, 'c> {
     pub owner: &'c Pubkey,
 }
 
-impl AssignWithSeed<'_, '_, '_> {
-    #[inline(always)]
-    pub fn invoke(&self) -> ProgramResult {
-        self.invoke_signed(&[])
-    }
-
-    #[inline(always)]
-    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        // account metadata
-        let account_metas: [AccountMeta; 2] = [
-            AccountMeta::writable(self.account.key()),
-            AccountMeta::readonly_signer(self.base.key()),
-        ];
+const ACCOUNTS_LEN: usize = 2;
 
+impl CanInvoke<ACCOUNTS_LEN> for AssignWithSeed<'_, '_, '_> {
+    fn invoke_via(
+        self,
+        invoke: impl FnOnce(
+            /* program_id: */ &Pubkey,
+            /* accounts: */ &[&AccountInfo; ACCOUNTS_LEN],
+            /* account_metas: */ &[AccountMeta],
+            /* data: */ &[u8],
+        ) -> ProgramResult,
+    ) -> ProgramResult {
         // instruction data
         // - [0..4  ]: instruction discriminator
         // - [4..36 ]: base pubkey
@@ -58,12 +54,14 @@ impl AssignWithSeed<'_, '_, '_> {
         instruction_data[44..offset].copy_from_slice(self.seed.as_bytes());
         instruction_data[offset..offset + 32].copy_from_slice(self.owner.as_ref());
 
-        let instruction = Instruction {
-            program_id: &crate::ID,
-            accounts: &account_metas,
-            data: &instruction_data[..offset + 32],
-        };
-
-        invoke_signed(&instruction, &[self.account, self.base], signers)
+        invoke(
+            &crate::ID,
+            &[self.account, self.base],
+            &[
+                AccountMeta::writable(self.account.key()),
+                AccountMeta::readonly_signer(self.base.key()),
+            ],
+            &instruction_data[..offset + 32],
+        )
     }
 }

programs/system/src/instructions/authorize_nonce_account.rs

@@ -1,11 +1,9 @@
 use pinocchio::{
-    account_info::AccountInfo,
-    instruction::{AccountMeta, Instruction, Signer},
-    program::invoke_signed,
-    pubkey::Pubkey,
-    ProgramResult,
+    account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey, ProgramResult,
 };
 
+use crate::CanInvoke;
+
 /// Change the entity authorized to execute nonce instructions on the account.
 ///
 /// The `Pubkey` parameter identifies the entity to authorize.
@@ -24,33 +22,33 @@ pub struct AuthorizeNonceAccount<'a, 'b> {
     pub new_authority: &'b Pubkey,
 }
 
-impl AuthorizeNonceAccount<'_, '_> {
-    #[inline(always)]
-    pub fn invoke(&self) -> ProgramResult {
-        self.invoke_signed(&[])
-    }
-
-    #[inline(always)]
-    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        // account metadata
-        let account_metas: [AccountMeta; 2] = [
-            AccountMeta::writable(self.account.key()),
-            AccountMeta::readonly_signer(self.authority.key()),
-        ];
-
+const ACCOUNTS_LEN: usize = 2;
+
+impl CanInvoke<ACCOUNTS_LEN> for AuthorizeNonceAccount<'_, '_> {
+    fn invoke_via(
+        self,
+        invoke: impl FnOnce(
+            /* program_id: */ &Pubkey,
+            /* accounts: */ &[&AccountInfo; ACCOUNTS_LEN],
+            /* account_metas: */ &[AccountMeta],
+            /* data: */ &[u8],
+        ) -> ProgramResult,
+    ) -> ProgramResult {
         // instruction data
         // -  [0..4 ]: instruction discriminator
         // -  [4..12]: lamports
         let mut instruction_data = [0; 36];
         instruction_data[0] = 7;
         instruction_data[4..36].copy_from_slice(self.new_authority);
 
-        let instruction = Instruction {
-            program_id: &crate::ID,
-            accounts: &account_metas,
-            data: &instruction_data,
-        };
-
-        invoke_signed(&instruction, &[self.account, self.authority], signers)
+        invoke(
+            &crate::ID,
+            &[self.account, self.authority],
+            &[
+                AccountMeta::writable(self.account.key()),
+                AccountMeta::readonly_signer(self.authority.key()),
+            ],
+            &instruction_data,
+        )
     }
 }