Merge pull request #74 from staratlasmeta/stegaBOB/feat/idl-finishing-touches

Feat: idl finishing touches

Author: stegaBOB

Cargo.lock

@@ -18,6 +18,7 @@ star_frame_idl = { path = "framework/star_frame_idl", features = ["verifier"] }
 star_frame_proc = { path = "framework/star_frame_proc" }
 advance = { path = "advance", features = ["solana"] }
 anyhow = "1.0.75"
+anchor-lang-idl-spec = "0.1.0"
 array-init = "2.1.0"
 bincode = { version = "1.3.3", features = ["i128"] }
 borsh = "1.3.1"

Cargo.toml

@@ -30,6 +30,6 @@ pub mod macro_prelude {
         item_source,
         seeds::{IdlFindSeed, IdlFindSeeds, IdlSeed, IdlSeeds},
         ty::{IdlEnumVariant, IdlStructField, IdlType, IdlTypeDef, IdlTypeId},
-        IdlDefinition, IdlDefinitionReference, ItemInfo, Version,
+        CrateMetadata, IdlDefinition, IdlDefinitionReference, ItemInfo, Version,
     };
 }

framework/star_frame/src/__private/mod.rs

@@ -183,24 +183,18 @@ impl<'a, 'info> AccountSetCleanup<'info, ()> for &'a AccountInfo<'info> {
 #[cfg(feature = "idl")]
 pub mod idl_impl {
     use super::*;
-    use crate::idl::AccountSetToIdl;
+    use crate::idl::{AccountSetToIdl, FindIdlSeeds};
+    use crate::prelude::Seeds;
     use star_frame_idl::account_set::{IdlAccountSetDef, IdlSingleAccountSet};
+    use star_frame_idl::seeds::IdlFindSeeds;
     use star_frame_idl::IdlDefinition;
 
     impl<'info> AccountSetToIdl<'info, ()> for AccountInfo<'info> {
         fn account_set_to_idl(
             _idl_definition: &mut IdlDefinition,
             _arg: (),
         ) -> Result<IdlAccountSetDef> {
-            Ok(IdlAccountSetDef::Single(IdlSingleAccountSet {
-                program_accounts: vec![],
-                seeds: None,
-                address: None,
-                writable: false,
-                signer: false,
-                optional: false,
-                is_init: false,
-            }))
+            Ok(IdlAccountSetDef::Single(IdlSingleAccountSet::default()))
         }
     }
     impl<'info> AccountSetToIdl<'info, Pubkey> for AccountInfo<'info> {
@@ -209,16 +203,49 @@ pub mod idl_impl {
             arg: Pubkey,
         ) -> Result<IdlAccountSetDef> {
             Ok(IdlAccountSetDef::Single(IdlSingleAccountSet {
-                program_accounts: vec![],
-                seeds: None,
                 address: Some(arg),
-                writable: false,
-                signer: false,
-                optional: false,
-                is_init: false,
+                ..Default::default()
+            }))
+        }
+    }
+
+    impl<'info, T> AccountSetToIdl<'info, Seeds<(T, Pubkey)>> for AccountInfo<'info>
+    where
+        T: FindIdlSeeds,
+    {
+        fn account_set_to_idl(
+            _idl_definition: &mut IdlDefinition,
+            arg: Seeds<(T, Pubkey)>,
+        ) -> Result<IdlAccountSetDef> {
+            let (seeds, program) = arg.0;
+            Ok(IdlAccountSetDef::Single(IdlSingleAccountSet {
+                seeds: Some(IdlFindSeeds {
+                    seeds: T::find_seeds(&seeds)?,
+                    program: Some(program),
+                }),
+                ..Default::default()
             }))
         }
     }
+
+    impl<'info, T> AccountSetToIdl<'info, Seeds<T>> for AccountInfo<'info>
+    where
+        T: FindIdlSeeds,
+    {
+        fn account_set_to_idl(
+            _idl_definition: &mut IdlDefinition,
+            arg: Seeds<T>,
+        ) -> Result<IdlAccountSetDef> {
+            Ok(IdlAccountSetDef::Single(IdlSingleAccountSet {
+                seeds: Some(IdlFindSeeds {
+                    seeds: T::find_seeds(&arg.0)?,
+                    program: None,
+                }),
+                ..Default::default()
+            }))
+        }
+    }
+
     impl<'a, 'info, A> AccountSetToIdl<'info, A> for &'a AccountInfo<'info>
     where
         AccountInfo<'info>: AccountSetToIdl<'info, A>,

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

@@ -11,8 +11,6 @@ pub use mutable::*;
 pub use seeded::*;
 pub use signer::*;
 
-// TODO: Add macros to make propagating the marker traits easier.
-
 /// A marker trait that indicates the underlying account is a signer
 pub trait SignedAccount<'info>: SingleAccountSet<'info> {
     /// Gets the seeds of the account if it is seeded.

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

@@ -1,5 +1,6 @@
-use crate::account_set::{AccountSet, SignedAccount, SingleAccountSet};
+use crate::account_set::{AccountSet, CanSetSeeds, SignedAccount, SingleAccountSet};
 
+use crate::prelude::SyscallInvoke;
 use crate::Result;
 use derive_more::{Deref, DerefMut};
 use solana_program::account_info::AccountInfo;
@@ -11,7 +12,7 @@ use std::fmt::Debug;
 #[validate(
     extra_validation = self.check_signer(),
 )]
-pub struct Signer<T>(#[single_account_set(skip_signed_account)] pub(crate) T);
+pub struct Signer<T>(#[single_account_set(skip_signed_account, skip_can_set_seeds)] pub(crate) T);
 
 pub type SignerInfo<'info> = Signer<AccountInfo<'info>>;
 
@@ -24,6 +25,16 @@ where
     }
 }
 
+// CanSetSeeds on Signer is a no-op
+impl<'info, T> CanSetSeeds<'info, ()> for Signer<T>
+where
+    Self: SingleAccountSet<'info>,
+{
+    fn set_seeds(&mut self, _arg: &(), _syscalls: &mut impl SyscallInvoke<'info>) -> Result<()> {
+        Ok(())
+    }
+}
+
 #[cfg(feature = "idl")]
 mod idl_impl {
     use super::*;

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

@@ -4,7 +4,7 @@ use star_frame_idl::account_set::IdlAccountSetDef;
 use star_frame_idl::instruction::IdlInstructionDef;
 use star_frame_idl::seeds::IdlSeeds;
 use star_frame_idl::ty::IdlTypeDef;
-use star_frame_idl::{IdlDefinition, IdlMetadata, Version};
+use star_frame_idl::{CrateMetadata, IdlDefinition, IdlMetadata};
 pub use star_frame_proc::{InstructionToIdl, TypeToIdl};
 
 mod find_seeds;
@@ -41,7 +41,7 @@ pub trait SeedsToIdl: GetSeeds {
 }
 
 pub trait ProgramToIdl: StarFrameProgram {
-    fn version() -> Version;
+    fn crate_metadata() -> CrateMetadata;
 
     fn program_to_idl() -> Result<IdlDefinition>
     where
@@ -50,7 +50,7 @@ pub trait ProgramToIdl: StarFrameProgram {
         let mut out = IdlDefinition {
             address: Self::PROGRAM_ID,
             metadata: IdlMetadata {
-                version: Self::version(),
+                crate_metadata: Self::crate_metadata(),
                 ..Default::default()
             },
             ..Default::default()

framework/star_frame/src/idl/mod.rs

@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use borsh::BorshDeserialize;
 use solana_program::system_program;
+use star_frame_idl::CrateMetadata;
 use system_instruction_impl::SystemInstructionSet;
 
 /// Solana's system program.
@@ -15,8 +16,16 @@ impl StarFrameProgram for SystemProgram {
 
 #[cfg(feature = "idl")]
 impl ProgramToIdl for SystemProgram {
-    fn version() -> star_frame_idl::Version {
-        star_frame_idl::Version::new(1, 18, 10)
+    fn crate_metadata() -> CrateMetadata {
+        CrateMetadata {
+            version: star_frame_idl::Version::new(1, 18, 10),
+            name: "system_program".to_string(),
+            docs: vec![],
+            description: None,
+            homepage: None,
+            license: None,
+            repository: None,
+        }
     }
 }
 

framework/star_frame/src/program/system_program.rs

@@ -5,11 +5,13 @@ edition.workspace = true
 publish.workspace = true
 
 [features]
-default = []
+default = ["anchor"]
 verifier = ["anyhow"]
+anchor = ["anchor-lang-idl-spec"]
 
 [dependencies]
 # verifier
+anchor-lang-idl-spec = { workspace = true, optional = true }
 anyhow = { workspace = true, optional = true }
 bincode = { workspace = true }
 derivative = { workspace = true }

framework/star_frame_idl/Cargo.toml

@@ -1,7 +1,7 @@
 use crate::account::IdlAccountId;
 use crate::seeds::IdlFindSeeds;
-use crate::serde_base58_pubkey_option;
 use crate::ty::IdlTypeDef;
+use crate::{serde_base58_pubkey_option, IdlDefinition};
 use crate::{IdlGeneric, ItemInfo};
 use crate::{ItemDescription, ItemSource};
 use anyhow::bail;
@@ -58,6 +58,24 @@ pub enum IdlAccountSetDef {
 }
 
 impl IdlAccountSetDef {
+    pub fn assert_defined(&self) -> anyhow::Result<&IdlAccountSetId> {
+        match self {
+            IdlAccountSetDef::Defined(id) => Ok(id),
+            _ => bail!("Expected defined account set, found {:?}", self),
+        }
+    }
+
+    pub fn get_defined<'a>(
+        &self,
+        idl_definition: &'a IdlDefinition,
+    ) -> anyhow::Result<&'a IdlAccountSet> {
+        let source = &self.assert_defined()?.source;
+        idl_definition
+            .account_sets
+            .get(source)
+            .ok_or_else(|| anyhow::anyhow!("Account set `{source}` not found in definition"))
+    }
+
     pub fn empty_struct() -> Self {
         IdlAccountSetDef::Struct(vec![])
     }