macro single account set + propagate marker traits

Author: stegaBOB

framework/example_programs/counter/src/lib.rs

@@ -1,5 +1,6 @@
 use star_frame::anyhow::bail;
 use star_frame::borsh::{BorshDeserialize, BorshSerialize};
+use star_frame::derive_more::{Deref, DerefMut};
 use star_frame::prelude::*;
 use star_frame::solana_program::pubkey::Pubkey;
 
@@ -14,10 +15,23 @@ pub struct CounterAccount {
 }
 
 impl ProgramAccount for CounterAccount {
-    type OwnerProgram = CounterProgram;
     const DISCRIMINANT: <Self::OwnerProgram as StarFrameProgram>::AccountDiscriminant = [0; 8];
 }
 
+#[derive(AccountSet, Deref, DerefMut, Debug)]
+#[cleanup(generics = [<A> where DataAccount<'info, CounterAccount>: AccountSetCleanup<'info, A>], arg = A)]
+#[validate(generics = [<A> where DataAccount<'info, CounterAccount>: AccountSetValidate<'info, A>], arg = A)]
+pub struct WrappedCounter<'info>(
+    #[cleanup(arg = arg)]
+    #[validate(arg = arg)]
+    #[single_account_set]
+    DataAccount<'info, CounterAccount>,
+);
+
+impl HasOwnerProgram for CounterAccount {
+    type OwnerProgram = CounterProgram;
+}
+
 impl HasSeeds for CounterAccount {
     type Seeds = CounterAccountSeeds;
 }
@@ -41,7 +55,7 @@ pub struct CreateCounterAccounts<'info> {
         CreateIfNeeded(CreateAccount::new(&self.system_program, &self.funder)),
         Seeds(CounterAccountSeeds { owner: *self.owner.key(), }),
     ))]
-    pub counter: Init<Seeded<DataAccount<'info, CounterAccount>>>,
+    pub counter: Init<Seeded<WrappedCounter<'info>>>,
     pub system_program: Program<'info, SystemProgram>,
 }
 
@@ -186,7 +200,7 @@ pub struct CloseCounterAccounts<'info> {
     #[account_set(recipient)]
     pub funds_to: Writable<SystemAccount<'info>>,
     #[cleanup(arg = NormalizeRentAuto)]
-    pub counter: Writable<DataAccount<'info, CounterAccount>>,
+    pub counter: Writable<WrappedCounter<'info>>,
 }
 
 impl StarFrameInstruction for CloseCounterIx {

framework/example_programs/faction_enlistment/src/lib.rs

@@ -37,7 +37,7 @@ pub struct ProcessEnlistPlayerIx {
 
 impl StarFrameInstruction for ProcessEnlistPlayerIx {
     type DecodeArg<'a> = ();
-    type ValidateArg<'a> = u8;
+    type ValidateArg<'a> = ();
     type CleanupArg<'a> = ();
     type ReturnType = ();
     // type RunArg<'a> = (FactionId, &'a Vec<u8>);
@@ -46,20 +46,15 @@ impl StarFrameInstruction for ProcessEnlistPlayerIx {
     // type ReturnType = usize;
 
     fn split_to_args<'a>(r: &Self) -> IxArgs<Self> {
-        IxArgs {
-            validate: r.bump,
-            run: r.faction_id,
-            // run: (r.faction_id, &r.buncha_data),
-            cleanup: (),
-            decode: (),
-        }
+        IxArgs::run(r.faction_id)
     }
 
     fn run_instruction<'info>(
         account_set: &mut Self::Accounts<'_, '_, 'info>,
         faction_id: Self::RunArg<'_>,
         syscalls: &mut impl SyscallInvoke<'info>,
     ) -> Result<Self::ReturnType> {
+        // let cloned_account = account_set.player_account.clone();
         let clock = syscalls.get_clock()?;
         let bump = account_set.player_faction_account.access_seeds().bump;
         *account_set.player_faction_account.data_mut()? = PlayerFactionData {
@@ -74,15 +69,18 @@ impl StarFrameInstruction for ProcessEnlistPlayerIx {
 }
 
 #[derive(AccountSet)]
-#[validate(arg = u8)]
-#[account_set(skip_default_idl)]
 pub struct ProcessEnlistPlayer<'info> {
     /// The player faction account
-    #[validate(arg = (Create(()),
+    #[validate(arg = (Create(CreateAccount::new(&self.system_program, &self.player_account)),
     Seeds(PlayerFactionAccountSeeds {
         player_account: *self.player_account.key()
     })))]
     pub player_faction_account: Init<Seeded<DataAccount<'info, PlayerFactionData>>>,
+    #[validate(arg  =Seeds(PlayerFactionAccountSeeds {
+        player_account: *self.player_account.key()
+    }))]
+    pub player_faction_account2:
+        Seeded<DataAccount<'info, PlayerFactionData>, PlayerFactionAccountSeeds, CurrentProgram>,
     /// The player account
     #[account_set(funder)]
     pub player_account: Writable<Signer<SystemAccount<'info>>>,
@@ -136,11 +134,14 @@ unsafe impl Zeroable for FactionId {}
 
 // TODO - Macro should derive this and with the idl feature enabled would also derive `AccountToIdl` and `TypeToIdl`
 impl ProgramAccount for PlayerFactionData {
-    type OwnerProgram = StarFrameDeclaredProgram;
     const DISCRIMINANT: <Self::OwnerProgram as StarFrameProgram>::AccountDiscriminant =
         [47, 44, 255, 15, 103, 77, 139, 247];
 }
 
+impl HasOwnerProgram for PlayerFactionData {
+    type OwnerProgram = FactionEnlistment;
+}
+
 impl HasSeeds for PlayerFactionData {
     type Seeds = PlayerFactionAccountSeeds;
 }
@@ -156,15 +157,17 @@ mod tests {
     use super::*;
     use bytemuck::checked::try_from_bytes;
     use solana_program_test::{processor, ProgramTest};
+    use solana_sdk::account::Account;
     use solana_sdk::clock::Clock;
-    use solana_sdk::signature::Signer;
+    use solana_sdk::signature::{Keypair, Signer};
     use star_frame::borsh::to_vec;
     use star_frame::itertools::Itertools;
     use star_frame::solana_program::instruction::AccountMeta;
+    use star_frame::solana_program::native_token::LAMPORTS_PER_SOL;
 
     #[tokio::test]
     async fn banks_test() -> Result<()> {
-        const SBF_FILE: bool = false;
+        const SBF_FILE: bool = true;
         let program_test = if SBF_FILE {
             let target_dir = std::env::current_dir()?
                 .join("../../../target/deploy")
@@ -186,24 +189,27 @@ mod tests {
             )
         };
 
-        let test_context = program_test.start_with_context().await;
+        let mut test_context = program_test.start_with_context().await;
+        let (player_account, (faction_account, bump)) = loop {
+            let key = Keypair::new();
+            let seeds = PlayerFactionAccountSeeds {
+                player_account: key.pubkey(),
+            };
+            let player_faction =
+                Pubkey::find_program_address(&seeds.seeds(), &StarFrameDeclaredProgram::PROGRAM_ID);
+            if player_faction.1 == 255 {
+                let data = Account {
+                    lamports: LAMPORTS_PER_SOL * 100,
+                    ..Default::default()
+                };
+                test_context.set_account(&key.pubkey(), &data.into());
+                break (key, player_faction);
+            }
+        };
         let mut banks_client = test_context.banks_client;
 
-        let player_account = test_context.payer;
-
-        let seeds = PlayerFactionAccountSeeds {
-            player_account: player_account.pubkey(),
-        };
-        let (faction_account, bump) =
-            Pubkey::find_program_address(&seeds.seeds(), &StarFrameDeclaredProgram::PROGRAM_ID);
-        println!("Bump: {}", bump);
         let faction_id = FactionId::MUD;
 
-        // let mut random_bytes = [0u8; 1];
-        // let mut rng = rand::thread_rng();
-        // rand::rngs::ThreadRng::try_fill(&mut rng, &mut random_bytes[..]).unwrap();
-        // let bunch_bytes = random_bytes.to_vec();
-
         let enlist_ix = ProcessEnlistPlayerIx {
             bump,
             faction_id,

framework/star_frame/src/__private/mod.rs

@@ -1,6 +1,10 @@
 pub mod macro_prelude {
+    pub use crate::account_set::{
+        AccountSet, CanInitAccount, CanSetSeeds, HasOwnerProgram, HasProgramAccount, HasSeeds,
+        SignedAccount, SingleAccountSet, SingleAccountSetMetadata, WritableAccount,
+    };
     pub use crate::instruction::{Instruction, InstructionDiscriminant};
-    pub use crate::syscalls::SyscallAccountCache;
+    pub use crate::syscalls::{SyscallAccountCache, SyscallInvoke};
     pub use crate::unsize::{
         AsBytes, AsMutBytes, FromBytesReturn, RefBytes, RefBytesMut, RefDeref, RefDerefMut,
         RefResize, RefWrapper, RefWrapperMutExt, RefWrapperTypes, Resize, UnsizedInit, UnsizedType,

framework/star_frame/src/account_set/data_account.rs

@@ -12,8 +12,7 @@ use std::marker::PhantomData;
 use std::mem::size_of;
 use std::slice::from_raw_parts_mut;
 
-pub trait ProgramAccount {
-    type OwnerProgram: StarFrameProgram;
+pub trait ProgramAccount: HasOwnerProgram {
     const DISCRIMINANT: <Self::OwnerProgram as StarFrameProgram>::AccountDiscriminant;
 }
 
@@ -93,6 +92,12 @@ pub struct CloseAccountAuto;
     }
 )]
 pub struct DataAccount<'info, T: ProgramAccount + UnsizedType + ?Sized> {
+    #[single_account_set(
+        skip_has_program_account,
+        skip_can_init_account,
+        skip_has_seeds,
+        skip_has_owner_program
+    )]
     #[validate(arg = arg)]
     info: AccountInfo<'info>,
     phantom_t: PhantomData<T>,
@@ -224,20 +229,14 @@ where
     }
 }
 
-impl<'info, T> SingleAccountSet<'info> for DataAccount<'info, T>
-where
-    T: ProgramAccount + UnsizedType + ?Sized,
-{
-    const METADATA: SingleAccountSetMetadata = SingleAccountSetMetadata::DEFAULT;
-    fn account_info(&self) -> &AccountInfo<'info> {
-        &self.info
-    }
-}
-
 impl<'info, T: ProgramAccount + UnsizedType + ?Sized> HasProgramAccount for DataAccount<'info, T> {
     type ProgramAccount = T;
 }
 
+impl<'info, T: ProgramAccount + UnsizedType + ?Sized> HasOwnerProgram for DataAccount<'info, T> {
+    type OwnerProgram = T::OwnerProgram;
+}
+
 impl<'info, T: ProgramAccount + UnsizedType + ?Sized> HasSeeds for DataAccount<'info, T>
 where
     T: HasSeeds,

framework/star_frame/src/account_set/funder.rs

@@ -11,6 +11,11 @@ use star_frame::prelude::*;
     skip_default_idl
 )]
 pub struct Funder<'info> {
+    #[single_account_set(metadata = SingleAccountSetMetadata {
+        should_sign: true,
+        should_mut: true,
+        ..SingleAccountSetMetadata::DEFAULT
+    }, skip_signed_account)]
     inner: Writable<SignerInfo<'info>>,
     #[account_set(skip = None)]
     seeds: Option<Vec<Vec<u8>>>,
@@ -26,24 +31,10 @@ impl<'info> Funder<'info> {
     }
 }
 
-impl<'info> SingleAccountSet<'info> for Funder<'info> {
-    const METADATA: SingleAccountSetMetadata = SingleAccountSetMetadata {
-        should_sign: true,
-        should_mut: true,
-        ..SingleAccountSetMetadata::DEFAULT
-    };
-
-    fn account_info(&self) -> &AccountInfo<'info> {
-        self.inner.account_info()
-    }
-}
-
 impl<'info> SignedAccount<'info> for Funder<'info> {
     fn signer_seeds(&self) -> Option<Vec<&[u8]>> {
         self.seeds
             .as_ref()
             .map(|seeds| seeds.iter().map(Vec::as_slice).collect())
     }
 }
-
-impl<'info> WritableAccount<'info> for Funder<'info> {}

framework/star_frame/src/account_set/modifiers/init.rs

@@ -67,48 +67,18 @@ pub struct Init<T>(
     #[validate(id = "create_generic", arg = arg.1)]
     #[validate(id = "create_if_needed_generic", arg = arg.1)]
     #[cleanup(arg = arg)]
+    #[single_account_set(
+        metadata = SingleAccountSetMetadata {
+            is_init: true,
+            should_mut: true,
+            ..T::METADATA
+        },
+        skip_can_set_seeds,
+        skip_can_init_account
+    )]
     T,
 );
 
-impl<'info, T> SingleAccountSet<'info> for Init<T>
-where
-    T: SingleAccountSet<'info>,
-{
-    const METADATA: SingleAccountSetMetadata = SingleAccountSetMetadata {
-        is_init: true,
-        should_mut: true,
-        ..T::METADATA
-    };
-    fn account_info(&self) -> &AccountInfo<'info> {
-        self.0.account_info()
-    }
-}
-
-impl<'info, T> SignedAccount<'info> for Init<T>
-where
-    T: SignedAccount<'info>,
-{
-    fn signer_seeds(&self) -> Option<Vec<&[u8]>> {
-        self.0.signer_seeds()
-    }
-}
-
-impl<'info, T> WritableAccount<'info> for Init<T> where T: SingleAccountSet<'info> {}
-
-impl<T> HasProgramAccount for Init<T>
-where
-    T: HasProgramAccount,
-{
-    type ProgramAccount = T::ProgramAccount;
-}
-
-impl<T> HasSeeds for Init<T>
-where
-    T: HasSeeds,
-{
-    type Seeds = T::Seeds;
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
 #[repr(transparent)]
 pub struct Create<T>(pub T);

framework/star_frame/src/account_set/modifiers/mod.rs

@@ -27,6 +27,11 @@ pub trait HasProgramAccount {
     type ProgramAccount: ProgramAccount + ?Sized;
 }
 
+/// A marker trait that indicates the underlying type is owned by a [`StarFrameProgram`].
+pub trait HasOwnerProgram {
+    type OwnerProgram: StarFrameProgram;
+}
+
 /// A marker trait that indicates the underlying type has seeds in it.
 pub trait HasSeeds {
     type Seeds: GetSeeds;