Merge pull request #71 from staratlasmeta/stegaBOB/feat/idl-wip2

Feat: Idl part 2

Author: bzierk

framework/example_programs/counter/src/lib.rs

@@ -1,8 +1,10 @@
+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, Pod, Zeroable, Copy, Clone, Debug, Eq, PartialEq, ProgramAccount)]
 #[program_account(seeds = CounterAccountSeeds)]
@@ -16,6 +18,7 @@ pub struct CounterAccount {
 }
 
 #[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>(
@@ -25,8 +28,17 @@ pub struct WrappedCounter<'info>(
     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,
 }
@@ -45,6 +57,7 @@ pub struct CreateCounterAccounts<'info> {
         CreateIfNeeded(()),
         Seeds(CounterAccountSeeds { owner: *self.owner.key(), }),
     ))]
+    #[idl(arg = Seeds(FindCounterAccountSeeds { owner: seed_path("owner") }))]
     pub counter: Init<Seeded<WrappedCounter<'info>>>,
     #[account_set(system_program)]
     pub system_program: Program<'info, SystemProgram>,

framework/example_programs/faction_enlistment/src/lib.rs

@@ -5,9 +5,6 @@ use star_frame::borsh;
 use star_frame::borsh::{BorshDeserialize, BorshSerialize};
 use star_frame::prelude::*;
 
-use star_frame::star_frame_idl::ty::{IdlEnumVariant, IdlType, IdlTypeDef, IdlTypeId};
-use star_frame::star_frame_idl::{item_source, IdlDefinition, ItemInfo};
-
 #[derive(StarFrameProgram)]
 #[program(
     instruction_set = FactionEnlistmentInstructionSet
@@ -81,6 +78,11 @@ pub struct ProcessEnlistPlayer<'info> {
     Seeds(PlayerFactionAccountSeeds {
         player_account: *self.player_account.key()
     })))]
+    #[idl(
+        arg = Seeds(FindPlayerFactionAccountSeeds {
+            player_account: seed_path("player_account")
+        })
+    )]
     pub player_faction_account: Init<Seeded<DataAccount<'info, PlayerFactionData>>>,
     /// The player account
     #[account_set(funder)]
@@ -114,8 +116,9 @@ pub struct PlayerFactionData {
     Eq,
     PartialEq,
     Default,
+    TypeToIdl,
 )]
-#[borsh(crate = "borsh")]
+#[borsh(crate = "borsh", use_discriminant = true)]
 #[repr(u8)]
 pub enum FactionId {
     #[default]
@@ -124,70 +127,10 @@ pub enum FactionId {
     Ustur,
 }
 
-impl TypeToIdl for FactionId {
-    type AssociatedProgram = crate::StarFrameDeclaredProgram;
-    fn type_to_idl(idl_definition: &mut IdlDefinition) -> Result<IdlTypeDef> {
-        let source = item_source::<Self>();
-        let type_def = IdlTypeDef::Enum(vec![
-            IdlEnumVariant {
-                name: "MUD".to_string(),
-                discriminant: vec![0],
-                type_def: None,
-            },
-            IdlEnumVariant {
-                name: "ONI".to_string(),
-                discriminant: vec![1],
-                type_def: None,
-            },
-            IdlEnumVariant {
-                name: "USTUR".to_string(),
-                discriminant: vec![2],
-                type_def: None,
-            },
-        ]);
-        let idl_type = IdlType {
-            info: ItemInfo {
-                name: "FactionId".to_string(),
-                description: vec![],
-                source: source.clone(),
-            },
-            type_def,
-            generics: vec![],
-        };
-        let namespace = idl_definition.add_type(idl_type, Self::AssociatedProgram::PROGRAM_ID);
-        Ok(IdlTypeDef::Defined(IdlTypeId {
-            namespace,
-            source,
-            provided_generics: vec![],
-        }))
-    }
-}
-
 unsafe impl Zeroable for FactionId {}
 
-// impl AccountToIdl for PlayerFactionData {
-//     fn account_to_idl(idl_definition: &mut IdlDefinition) -> Result<IdlAccountId> {
-//         let source = item_source::<Self>();
-//         let idl_account = IdlAccount {
-//             discriminant: Self::discriminant_bytes(),
-//             seeds: Some(IdlSeeds(vec![
-//                 IdlSeed::Const(b"FACTION_ENLISTMENT".into()),
-//                 IdlSeed::Variable(IdlVariableSeed {
-//                     name: "player_account".to_string(),
-//                     description: vec![],
-//                     ty: <Pubkey>::type_to_idl(idl_definition)?,
-//                 }),
-//             ])),
-//             type_def: <PlayerFactionData>::type_to_idl(idl_definition)?,
-//         };
-//         let namespace =
-//             idl_definition.add_account(idl_account, Self::AssociatedProgram::PROGRAM_ID)?;
-//         Ok(IdlAccountId { namespace, source })
-//     }
-// }
-
 #[derive(Debug, GetSeeds, Clone)]
-#[seed_const(b"FACTION_ENLISTMENT")]
+#[get_seeds(seed_const = b"FACTION_ENLISTMENT")]
 pub struct PlayerFactionAccountSeeds {
     player_account: Pubkey,
 }

framework/star_frame/src/__private/mod.rs

@@ -1,7 +1,7 @@
 pub mod macro_prelude {
     pub use crate::account_set::{
-        AccountSet, CanInitAccount, CanSetSeeds, HasOwnerProgram, HasProgramAccount, HasSeeds,
-        ProgramAccount, SignedAccount, SingleAccountSet, WritableAccount,
+        AccountSet, CanInitAccount, CanSetSeeds, GetSeeds, HasOwnerProgram, HasProgramAccount,
+        HasSeeds, ProgramAccount, Seed, SignedAccount, SingleAccountSet, WritableAccount,
     };
     pub use crate::instruction::{
         Instruction, InstructionDiscriminant, InstructionSet, StarFrameInstruction,
@@ -18,8 +18,8 @@ pub mod macro_prelude {
 
     #[cfg(feature = "idl")]
     pub use crate::idl::{
-        AccountSetToIdl, AccountToIdl, InstructionSetToIdl, InstructionToIdl, ProgramToIdl,
-        TypeToIdl,
+        seed_const, seed_path, AccountSetToIdl, AccountToIdl, FindIdlSeeds, FindSeed,
+        InstructionSetToIdl, InstructionToIdl, ProgramToIdl, SeedsToIdl, TypeToIdl,
     };
 
     #[cfg(feature = "idl")]
@@ -28,6 +28,7 @@ pub mod macro_prelude {
         account_set::{IdlAccountSet, IdlAccountSetDef, IdlAccountSetId, IdlAccountSetStructField},
         instruction::{IdlInstruction, IdlInstructionDef},
         item_source,
+        seeds::{IdlFindSeed, IdlFindSeeds, IdlSeed, IdlSeeds},
         ty::{IdlEnumVariant, IdlStructField, IdlType, IdlTypeDef, IdlTypeId},
         IdlDefinition, IdlDefinitionReference, ItemInfo, Version,
     };

framework/star_frame/src/account_set/data_account.rs

@@ -126,13 +126,11 @@ mod idl_impl {
             idl_definition: &mut IdlDefinition,
             arg: A,
         ) -> Result<IdlAccountSetDef> {
-            Ok(IdlAccountSetDef::ProgramAccount {
-                account_set: Box::new(<AccountInfo<'info>>::account_set_to_idl(
-                    idl_definition,
-                    arg,
-                )?),
-                account_id: T::account_to_idl(idl_definition)?,
-            })
+            let mut set = <AccountInfo<'info>>::account_set_to_idl(idl_definition, arg)?;
+            set.single()?
+                .program_accounts
+                .push(T::account_to_idl(idl_definition)?);
+            Ok(set)
         }
     }
 }

framework/star_frame/src/account_set/impls/account_info.rs

@@ -220,7 +220,7 @@ pub mod idl_impl {
             _idl_definition: &mut IdlDefinition,
             _arg: (),
         ) -> Result<IdlAccountSetDef> {
-            Ok(IdlAccountSetDef::SingleAccount(IdlSingleAccountSet {
+            Ok(IdlAccountSetDef::Single(IdlSingleAccountSet {
                 program_accounts: vec![],
                 seeds: None,
                 address: None,

framework/star_frame/src/account_set/impls/option.rs

@@ -203,6 +203,9 @@ mod idl_impl {
     use star_frame_idl::account_set::IdlAccountSetDef;
     use star_frame_idl::IdlDefinition;
 
+    // todo: figure out our optionals for IDLs. Thinking we should remove our separate decode
+    //  strategies and just use the program id method. This would make using option much simpler on
+    //  arg side and be more in line with how the rest of the ecosystem handles optionals.
     impl<'info, A, Arg> AccountSetToIdl<'info, Arg> for Option<A>
     where
         A: AccountSetToIdl<'info, Arg>,
@@ -211,10 +214,14 @@ mod idl_impl {
             idl_definition: &mut IdlDefinition,
             arg: Arg,
         ) -> Result<IdlAccountSetDef> {
-            let inner = A::account_set_to_idl(idl_definition, arg)?;
+            let mut set = A::account_set_to_idl(idl_definition, arg)?;
+            if let Ok(inner) = set.single() {
+                inner.optional = true;
+                return Ok(set);
+            }
             Ok(IdlAccountSetDef::Or(vec![
-                IdlAccountSetDef::Struct(vec![]),
-                inner,
+                set,
+                IdlAccountSetDef::empty_struct(),
             ]))
         }
     }

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

@@ -37,9 +37,9 @@ mod idl_impl {
             idl_definition: &mut IdlDefinition,
             arg: A,
         ) -> Result<IdlAccountSetDef> {
-            T::account_set_to_idl(idl_definition, arg)
-                .map(Box::new)
-                .map(IdlAccountSetDef::Writable)
+            let mut set = T::account_set_to_idl(idl_definition, arg)?;
+            set.single()?.writable = true;
+            Ok(set)
         }
     }
 }