Merge pull request #67 from staratlasmeta/stegaBOB/feat/single-account-set-macro

Feat: macro single account set + propagate marker traits

Author: bzierk

Cargo.lock

@@ -52,6 +52,7 @@ syn = { version = "2.0.40", features = ["extra-traits"] }
 typenum = "1.17.0"
 sha2 = "0.10.8"
 pretty_assertions = "1.4.0"
+semver = { version = "1.0.23", features = ["serde"] }
 
 # version locks
 bumpalo = "~3.14.0"

Cargo.toml

@@ -1,9 +1,13 @@
+use star_frame::__private::macro_prelude::IdlAccountSetDef;
 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;
+use star_frame::star_frame_idl::IdlDefinition;
 
-#[derive(Align1, Copy, Clone, Debug, Eq, PartialEq, Pod, Zeroable)]
+#[derive(Align1, Pod, Zeroable, Copy, Clone, Debug, Eq, PartialEq, ProgramAccount)]
+#[program_account(seeds = CounterAccountSeeds)]
 #[repr(C, packed)]
 pub struct CounterAccount {
     pub version: u8,
@@ -13,36 +17,48 @@ pub struct CounterAccount {
     pub bump: u8,
 }
 
-impl ProgramAccount for CounterAccount {
-    type OwnerProgram = CounterProgram;
-    const DISCRIMINANT: <Self::OwnerProgram as StarFrameProgram>::AccountDiscriminant = [0; 8];
-}
-
-impl HasSeeds for CounterAccount {
-    type Seeds = CounterAccountSeeds;
+#[derive(AccountSet, Deref, DerefMut, Debug)]
+#[account_set(skip_default_idl)]
+#[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<'info, A> AccountSetToIdl<'info, A> for WrappedCounter<'info>
+where
+    DataAccount<'info, CounterAccount>: AccountSetToIdl<'info, A>,
+{
+    fn account_set_to_idl(idl_definition: &mut IdlDefinition, arg: A) -> Result<IdlAccountSetDef> {
+        <DataAccount<'info, CounterAccount>>::account_set_to_idl(idl_definition, arg)
+    }
 }
 
 #[derive(Debug, GetSeeds, Clone)]
-#[seed_const(b"COUNTER")]
+#[get_seeds(seed_const = b"COUNTER")]
 pub struct CounterAccountSeeds {
     pub owner: Pubkey,
 }
 
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
+#[derive(BorshSerialize, BorshDeserialize, Debug, InstructionToIdl)]
 pub struct CreateCounterIx {
     pub start_at: Option<u64>,
 }
 
 #[derive(AccountSet)]
 pub struct CreateCounterAccounts<'info> {
     #[account_set(funder)]
-    pub funder: Signer<Writable<SystemAccount<'info>>>,
+    pub funder: Signer<Mut<SystemAccount<'info>>>,
     pub owner: SystemAccount<'info>,
     #[validate(arg = (
         CreateIfNeeded(()),
         Seeds(CounterAccountSeeds { owner: *self.owner.key(), }),
     ))]
-    pub counter: Init<Seeded<DataAccount<'info, CounterAccount>>>,
+    #[idl(arg = Seeds(FindCounterAccountSeeds { owner: seed_path("owner") }))]
+    pub counter: Init<Seeded<WrappedCounter<'info>>>,
     #[account_set(system_program)]
     pub system_program: Program<'info, SystemProgram>,
 }
@@ -81,15 +97,15 @@ impl StarFrameInstruction for CreateCounterIx {
     }
 }
 
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
-pub struct UpdateCounterSignerIx {}
+#[derive(BorshSerialize, BorshDeserialize, Debug, InstructionToIdl)]
+pub struct UpdateCounterSignerIx;
 
 #[derive(AccountSet, Debug)]
 #[validate(extra_validation = self.validate())]
 pub struct UpdateCounterSignerAccounts<'info> {
     pub signer: Signer<SystemAccount<'info>>,
     pub new_signer: SystemAccount<'info>,
-    pub counter: Writable<DataAccount<'info, CounterAccount>>,
+    pub counter: Mut<DataAccount<'info, CounterAccount>>,
 }
 
 impl<'info> UpdateCounterSignerAccounts<'info> {
@@ -127,7 +143,7 @@ impl StarFrameInstruction for UpdateCounterSignerIx {
     }
 }
 
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
+#[derive(BorshSerialize, BorshDeserialize, Debug, InstructionToIdl)]
 pub struct CountIx {
     pub amount: u64,
     pub subtract: bool,
@@ -137,7 +153,7 @@ pub struct CountIx {
 #[validate(extra_validation = self.validate())]
 pub struct CountAccounts<'info> {
     pub owner: Signer<SystemAccount<'info>>,
-    pub counter: Writable<DataAccount<'info, CounterAccount>>,
+    pub counter: Mut<DataAccount<'info, CounterAccount>>,
 }
 
 impl<'info> CountAccounts<'info> {
@@ -178,17 +194,17 @@ impl StarFrameInstruction for CountIx {
     }
 }
 
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
-pub struct CloseCounterIx {}
+#[derive(BorshSerialize, BorshDeserialize, Debug, InstructionToIdl)]
+pub struct CloseCounterIx;
 
 #[derive(AccountSet, Debug)]
 pub struct CloseCounterAccounts<'info> {
     #[validate(arg = &self.counter.data()?.signer)]
     pub signer: Signer<SystemAccount<'info>>,
     #[account_set(recipient)]
-    pub funds_to: Writable<SystemAccount<'info>>,
+    pub funds_to: Mut<SystemAccount<'info>>,
     #[cleanup(arg = CloseAccountAuto)]
-    pub counter: Writable<DataAccount<'info, CounterAccount>>,
+    pub counter: Mut<WrappedCounter<'info>>,
 }
 
 impl StarFrameInstruction for CloseCounterIx {
@@ -212,7 +228,7 @@ impl StarFrameInstruction for CloseCounterIx {
     }
 }
 
-#[star_frame_instruction_set]
+#[derive(InstructionSet)]
 pub enum CounterInstructionSet {
     CreateCounter(CreateCounterIx),
     UpdateSigner(UpdateCounterSignerIx),
@@ -222,10 +238,10 @@ pub enum CounterInstructionSet {
 
 #[derive(StarFrameProgram)]
 #[program(
-    instruction_set = CounterInstructionSet<'static>,
-    id =  "Coux9zxTFKZpRdFpE4F7Fs5RZ6FdaURdckwS61BUTMG",
+    instruction_set = CounterInstructionSet,
+    id = "Coux9zxTFKZpRdFpE4F7Fs5RZ6FdaURdckwS61BUTMG",
 )]
-pub struct CounterProgram {}
+pub struct CounterProgram;
 
 #[cfg(test)]
 mod tests {
@@ -238,8 +254,15 @@ mod tests {
     use solana_sdk::system_program;
     use solana_sdk::transaction::Transaction;
     use star_frame::itertools::Itertools;
+    use star_frame::serde_json;
     use star_frame::solana_program::instruction::AccountMeta;
 
+    #[test]
+    fn idl_test() {
+        let idl = CounterProgram::program_to_idl().unwrap();
+        println!("{}", serde_json::to_string_pretty(&idl).unwrap());
+    }
+
     #[tokio::test]
     async fn test_that_it_works() {
         let program_test = ProgramTest::new(