Merge pull request #77 from staratlasmeta/discriminants

Feat: instruction set repr discriminants and system program client (better than native!)

Author: stegaBOB

framework/star_frame/src/account_set/data_account.rs

@@ -1,12 +1,13 @@
 use crate::prelude::*;
+use crate::program::system_program;
+use crate::program::system_program::CreateAccountCpiAccounts;
 use crate::util::*;
 use advance::Advance;
 use anyhow::{bail, Context};
 use bytemuck::{bytes_of, from_bytes};
 use derivative::Derivative;
 use solana_program::entrypoint::MAX_PERMITTED_DATA_INCREASE;
 use solana_program::program_memory::sol_memset;
-use solana_program::system_instruction;
 pub use star_frame_proc::ProgramAccount;
 use std::cell::{Ref, RefMut};
 use std::marker::PhantomData;
@@ -301,30 +302,30 @@ where
         let rent = syscalls.get_rent()?;
         let size =
             T::INIT_BYTES + size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>();
-        let ix = system_instruction::create_account(
-            funder.key(),
-            self.key(),
-            rent.minimum_balance(size),
-            size as u64,
-            &T::OwnerProgram::PROGRAM_ID,
-        );
-        let accounts: &[AccountInfo<'info>] = &[
-            self.account_info_cloned(),
-            system_program.account_info_cloned(),
-            funder.account_info_cloned(),
-        ];
+        let cpi = SystemProgram::cpi(
+            &system_program::CreateAccount {
+                lamports: rent.minimum_balance(size),
+                owner: T::OwnerProgram::PROGRAM_ID,
+                space: size as u64,
+            },
+            CreateAccountCpiAccounts {
+                funder: funder.account_info_cloned(),
+                new_account: self.account_info_cloned(),
+            },
+        )?;
+
         match (funder.signer_seeds(), account_seeds) {
             (None, None) => {
-                syscalls.invoke(&ix, accounts)?;
+                cpi.invoke(syscalls)?;
             }
             (Some(funder), None) => {
-                syscalls.invoke_signed(&ix, accounts, &[&funder])?;
+                cpi.invoke_signed(syscalls, &[&funder])?;
             }
             (None, Some(account_seeds)) => {
-                syscalls.invoke_signed(&ix, accounts, &[&account_seeds])?;
+                cpi.invoke_signed(syscalls, &[&account_seeds])?;
             }
             (Some(funder), Some(account_seeds)) => {
-                syscalls.invoke_signed(&ix, accounts, &[&account_seeds, &funder])?;
+                cpi.invoke_signed(syscalls, &[&account_seeds, &funder])?;
             }
         }
         {

framework/star_frame/src/account_set/single_set.rs

@@ -1,13 +1,13 @@
 use crate::account_set::{AccountSet, HasOwnerProgram, Program, SignedAccount, WritableAccount};
 use crate::anyhow::Result;
-use crate::client::ClientAccountSet;
+use crate::client::{ClientAccountSet, MakeCpi};
 use crate::prelude::{StarFrameProgram, SyscallInvoke, SystemProgram};
+use crate::program::system_program::{Transfer, TransferCpiAccounts};
 use anyhow::anyhow;
 use solana_program::account_info::AccountInfo;
 use solana_program::instruction::AccountMeta;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
-use solana_program::system_instruction::transfer;
 use star_frame::client::CpiAccountSet;
 use std::cell::{Ref, RefMut};
 use std::cmp::Ordering;
@@ -146,8 +146,8 @@ where
 }
 
 pub trait CanCloseAccount<'info>: SingleAccountSet<'info> {
-    /// Closes the account by zeroing the lamports and leaving the data as the
-    /// [`StarFrameProgram::CLOSED_ACCOUNT_DISCRIMINANT`], reallocating down to size.
+    /// Closes the account by zeroing the lamports and replacing the discriminant with all `u8::MAX`,
+    /// reallocating down to size.
     fn close(&self, recipient: &impl WritableAccount<'info>) -> Result<()>
     where
         Self: HasOwnerProgram,
@@ -185,7 +185,7 @@ pub trait CanModifyRent<'info>: SingleAccountSet<'info> {
     fn normalize_rent<F: WritableAccount<'info> + SignedAccount<'info>>(
         &self,
         funder: &F,
-        system_program: &Program<'info, SystemProgram>,
+        _system_program: &Program<'info, SystemProgram>,
         syscalls: &impl SyscallInvoke<'info>,
     ) -> Result<()> {
         let rent = syscalls.get_rent()?;
@@ -199,25 +199,20 @@ pub trait CanModifyRent<'info>: SingleAccountSet<'info> {
                     return Ok(());
                 }
                 let transfer_amount = rent_lamports - lamports;
-                if funder.owner() == system_program.key() {
-                    let transfer_ix = transfer(funder.key(), self.key(), transfer_amount);
-                    let transfer_accounts =
-                        &[self.account_info_cloned(), funder.account_info_cloned()];
-                    match funder.signer_seeds() {
-                        None => syscalls
-                            .invoke(&transfer_ix, transfer_accounts)
-                            .map_err(Into::into),
-                        Some(seeds) => syscalls
-                            .invoke_signed(&transfer_ix, transfer_accounts, &[&seeds])
-                            .map_err(Into::into),
-                    }
-                } else {
-                    Err(anyhow!(
-                        "Funder account `{}` is not owned by the system program, owned by `{}`",
-                        funder.key(),
-                        funder.owner()
-                    ))
-                }
+                let cpi = SystemProgram::cpi(
+                    &Transfer {
+                        lamports: transfer_amount,
+                    },
+                    TransferCpiAccounts {
+                        funder: funder.account_info_cloned(),
+                        recipient: self.account_info_cloned(),
+                    },
+                )?;
+                match funder.signer_seeds() {
+                    None => cpi.invoke(syscalls)?,
+                    Some(seeds) => cpi.invoke_signed(syscalls, &[&seeds])?,
+                };
+                Ok(())
             }
             Ordering::Less => {
                 let transfer_amount = lamports - rent_lamports;

framework/star_frame/src/client.rs

@@ -48,8 +48,8 @@ impl<'info> CpiBuilder<'info> {
 
     pub fn invoke_signed(
         &self,
-        signer_seeds: &[&[&[u8]]],
         syscalls: &impl SyscallInvoke<'info>,
+        signer_seeds: &[&[&[u8]]],
     ) -> ProgramResult {
         syscalls.invoke_signed(&self.instruction, &self.accounts, signer_seeds)
     }

framework/star_frame/src/instruction/mod.rs

@@ -302,6 +302,7 @@ mod test {
 
     #[allow(dead_code)]
     #[derive(InstructionSet)]
+    #[ix_set(skip_idl)]
     enum TestInstructionSet3 {
         Ix1(Ix1),
         Ix2(Ix2),

framework/star_frame/src/program/mod.rs

@@ -15,7 +15,6 @@ pub trait StarFrameProgram {
     type InstructionSet: InstructionSet;
 
     type AccountDiscriminant: Pod + Eq;
-    const CLOSED_ACCOUNT_DISCRIMINANT: Self::AccountDiscriminant;
 
     const PROGRAM_ID: Pubkey;