Add remaining instructions

Author: febo

programs/system/src/instructions/advance_nonce_account.rs

@@ -5,6 +5,12 @@ use pinocchio::{
     program::invoke_signed,
 };
 
+/// Consumes a stored nonce, replacing it with a successor.
+///
+/// ### Accounts:
+///   0. `[WRITE]` Nonce account
+///   1. `[]` RecentBlockhashes sysvar
+///   2. `[SIGNER]` Nonce authority
 pub struct AdvanceNonceAccount<'a> {
     /// Nonce account.
     pub account: &'a AccountInfo,
@@ -30,18 +36,17 @@ impl<'a> AdvanceNonceAccount<'a> {
             AccountMeta::readonly_signer(self.authority.key()),
         ];
 
-        // instruction data
-        // -  [0..4 ]: instruction discriminator
-        let mut instruction_data = [0; 4];
-        // assign instruction has a '1' discriminator
-        instruction_data[0] = 4;
-
+        // instruction
         let instruction = Instruction {
             program_id: &crate::ID,
             accounts: &account_metas,
-            data: &instruction_data,
+            data: &[4],
         };
 
-        invoke_signed(&instruction, &[self.account], signers)
+        invoke_signed(
+            &instruction,
+            &[self.account, self.recent_blockhashes_sysvar, self.authority],
+            signers,
+        )
     }
 }

programs/system/src/instructions/allocate.rs

@@ -0,0 +1,45 @@
+use pinocchio::{
+    account_info::AccountInfo,
+    entrypoint::ProgramResult,
+    instruction::{AccountMeta, Instruction, Signer},
+    program::invoke_signed,
+};
+
+/// Allocate space in a (possibly new) account without funding.
+///
+/// ### Accounts:
+///   0. `[WRITE, SIGNER]` New account
+pub struct Allocate<'a> {
+    /// Account to be assigned.
+    pub account: &'a AccountInfo,
+
+    /// Number of bytes of memory to allocate.
+    pub space: u64,
+}
+
+impl<'a> Allocate<'a> {
+    #[inline(always)]
+    pub fn invoke(&self) -> ProgramResult {
+        self.invoke_signed(&[])
+    }
+
+    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
+        // account metadata
+        let account_metas: [AccountMeta; 1] = [AccountMeta::writable_signer(self.account.key())];
+
+        // 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)
+    }
+}

programs/system/src/instructions/allocate_with_seed.rs

@@ -0,0 +1,74 @@
+use pinocchio::{
+    account_info::AccountInfo,
+    entrypoint::ProgramResult,
+    instruction::{AccountMeta, Instruction, Signer},
+    program::invoke_signed,
+    pubkey::Pubkey,
+};
+
+/// Allocate space for and assign an account at an address derived
+/// from a base public key and a seed.
+///
+/// ### Accounts:
+///   0. `[WRITE]` Allocated account
+///   1. `[SIGNER]` Base account
+pub struct AllocateWithSeed<'a, 'b, 'c> {
+    /// Allocated account.
+    pub account: &'a AccountInfo,
+
+    /// Base account.
+    ///
+    /// The account matching the base Pubkey below must be provided as
+    /// a signer, but may be the same as the funding account and provided
+    /// as account 0.
+    pub base: &'a AccountInfo,
+
+    /// String of ASCII chars, no longer than `Pubkey::MAX_SEED_LEN`.
+    pub seed: &'b str,
+
+    /// Number of bytes of memory to allocate.
+    pub space: u64,
+
+    /// Address of program that will own the new account.
+    pub owner: &'c Pubkey,
+}
+
+impl<'a, 'b, 'c> AllocateWithSeed<'a, 'b, 'c> {
+    #[inline(always)]
+    pub fn invoke(&self) -> ProgramResult {
+        self.invoke_signed(&[])
+    }
+
+    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
+        // account metadata
+        let account_metas: [AccountMeta; 2] = [
+            AccountMeta::writable_signer(self.account.key()),
+            AccountMeta::readonly_signer(self.base.key()),
+        ];
+
+        // instruction data
+        // - [0..4  ]: instruction discriminator
+        // - [4..36 ]: base pubkey
+        // - [36..40]: seed length
+        // - [40..  ]: seed (max 32)
+        // - [..  +8]: account space
+        // - [.. +32]: owner pubkey
+        let mut instruction_data = [0; 112];
+        instruction_data[0] = 9;
+        instruction_data[4..36].copy_from_slice(self.base.key());
+        instruction_data[36..40].copy_from_slice(&u32::to_le_bytes(self.seed.len() as u32));
+
+        let offset = 40 + self.seed.len();
+        instruction_data[40..offset].copy_from_slice(self.seed.as_bytes());
+        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)
+    }
+}

programs/system/src/instructions/assign.rs

@@ -6,6 +6,10 @@ use pinocchio::{
     pubkey::Pubkey,
 };
 
+/// Assign account to a program
+///
+/// ### Accounts:
+///   0. `[WRITE, SIGNER]` Assigned account public key
 pub struct Assign<'a, 'b> {
     /// Account to be assigned.
     pub account: &'a AccountInfo,
@@ -28,7 +32,6 @@ impl<'a, 'b> Assign<'a, 'b> {
         // -  [0..4 ]: instruction discriminator
         // -  [4..36]: owner pubkey
         let mut instruction_data = [0; 36];
-        // assign instruction has a '1' discriminator
         instruction_data[0] = 1;
         instruction_data[4..36].copy_from_slice(self.owner.as_ref());
 

programs/system/src/instructions/assign_with_seed.rs

@@ -0,0 +1,68 @@
+use pinocchio::{
+    account_info::AccountInfo,
+    entrypoint::ProgramResult,
+    instruction::{AccountMeta, Instruction, Signer},
+    program::invoke_signed,
+    pubkey::Pubkey,
+};
+
+/// Assign account to a program based on a seed.
+///
+/// ### Accounts:
+///   0. `[WRITE]` Assigned account
+///   1. `[SIGNER]` Base account
+pub struct AssignWithSeed<'a, 'b, 'c> {
+    /// Allocated account.
+    pub account: &'a AccountInfo,
+
+    /// Base account.
+    ///
+    /// The account matching the base Pubkey below must be provided as
+    /// a signer, but may be the same as the funding account and provided
+    /// as account 0.
+    pub base: &'a AccountInfo,
+
+    /// String of ASCII chars, no longer than `Pubkey::MAX_SEED_LEN`.
+    pub seed: &'b str,
+
+    /// Address of program that will own the new account.
+    pub owner: &'c Pubkey,
+}
+
+impl<'a, 'b, 'c> AssignWithSeed<'a, 'b, 'c> {
+    #[inline(always)]
+    pub fn invoke(&self) -> ProgramResult {
+        self.invoke_signed(&[])
+    }
+
+    pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
+        // account metadata
+        let account_metas: [AccountMeta; 2] = [
+            AccountMeta::writable_signer(self.account.key()),
+            AccountMeta::readonly_signer(self.base.key()),
+        ];
+
+        // instruction data
+        // - [0..4  ]: instruction discriminator
+        // - [4..36 ]: base pubkey
+        // - [36..40]: seed length
+        // - [40..  ]: seed (max 32)
+        // - [.. +32]: owner pubkey
+        let mut instruction_data = [0; 104];
+        instruction_data[0] = 10;
+        instruction_data[4..36].copy_from_slice(self.base.key());
+        instruction_data[36..40].copy_from_slice(&u32::to_le_bytes(self.seed.len() as u32));
+
+        let offset = 40 + self.seed.len();
+        instruction_data[40..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)
+    }
+}

programs/system/src/instructions/authorize_nonce_account.rs

@@ -0,0 +1,55 @@
+use pinocchio::{
+    account_info::AccountInfo,
+    entrypoint::ProgramResult,
+    instruction::{AccountMeta, Instruction, Signer},
+    program::invoke_signed,
+    pubkey::Pubkey,
+};
+
+/// Change the entity authorized to execute nonce instructions on the account.
+///
+/// The `Pubkey` parameter identifies the entity to authorize.
+///
+/// ### Accounts:
+///   0. `[WRITE]` Nonce account
+///   1. `[SIGNER]` Nonce authority
+pub struct AuthorizeNonceAccount<'a, 'b> {
+    /// Nonce account.
+    pub account: &'a AccountInfo,
+
+    /// Nonce authority.
+    pub authority: &'a AccountInfo,
+
+    /// New entity authorized to execute nonce instructions on the account.
+    pub new_authority: &'b Pubkey,
+}
+
+impl<'a, 'b> AuthorizeNonceAccount<'a, 'b> {
+    #[inline(always)]
+    pub fn invoke(&self) -> ProgramResult {
+        self.invoke_signed(&[])
+    }
+
+    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()),
+        ];
+
+        // 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)
+    }
+}

programs/system/src/instructions/create_account.rs

@@ -7,6 +7,10 @@ use pinocchio::{
 };
 
 /// Create a new account.
+///
+/// ### Accounts:
+///   0. `[WRITE, SIGNER]` Funding account
+///   1. `[WRITE, SIGNER]` New account
 pub struct CreateAccount<'a> {
     /// Funding account.
     pub from: &'a AccountInfo,

programs/system/src/instructions/create_account_with_seed.rs

@@ -7,6 +7,13 @@ use pinocchio::{
 };
 
 /// Create a new account at an address derived from a base pubkey and a seed.
+///
+/// ### Accounts:
+///   0. `[WRITE, SIGNER]` Funding account
+///   1. `[WRITE]` Created account
+///   2. `[SIGNER]` (optional) Base account; the account matching the base Pubkey below must be
+///                          provided as a signer, but may be the same as the funding account
+///             
 pub struct CreateAccountWithSeed<'a, 'b, 'c> {
     /// Funding account.
     pub from: &'a AccountInfo,
@@ -57,7 +64,6 @@ impl<'a, 'b, 'c> CreateAccountWithSeed<'a, 'b, 'c> {
         // - [..  +8]: account space
         // - [.. +32]: owner pubkey
         let mut instruction_data = [0; 120];
-        // create account with seed instruction has a '3' discriminator
         instruction_data[0] = 3;
         instruction_data[4..36].copy_from_slice(self.base.unwrap_or(self.from).key());
         instruction_data[36..40].copy_from_slice(&u32::to_le_bytes(self.seed.len() as u32));
@@ -74,6 +80,10 @@ impl<'a, 'b, 'c> CreateAccountWithSeed<'a, 'b, 'c> {
             data: &instruction_data[..offset + 48],
         };
 
-        invoke_signed(&instruction, &[self.from, self.to], signers)
+        invoke_signed(
+            &instruction,
+            &[self.from, self.to, self.base.unwrap_or(self.from)],
+            signers,
+        )
     }
 }