Merge pull request #86 from staratlasmeta/stegaBOB/feat/spl-part-2

Feat: spl part 2

Author: stegaBOB

Cargo.lock

@@ -67,6 +67,7 @@ strum = { version = "0.26.2", features = ["derive"] }
 syn = { version = "2.0.40", features = ["extra-traits"] }
 tokio = "1.41.1"
 typenum = "1.17.0"
+ref-cast = "1.0"
 
 [profile.release]
 overflow-checks = true

Cargo.toml

@@ -1,10 +1,11 @@
-// #![allow(clippy::result_large_err)]
-
 use star_frame::borsh;
 use star_frame::borsh::{BorshDeserialize, BorshSerialize};
 use star_frame::prelude::*;
+use star_frame_spl::associated_token::AssociatedTokenAccount;
 use star_frame_spl::associated_token::AssociatedTokenProgram;
-use star_frame_spl::token::{InitMint, MintAccount, TokenProgram};
+use star_frame_spl::associated_token::InitAta;
+use star_frame_spl::token::InitMint;
+use star_frame_spl::token::{MintAccount, TokenProgram};
 
 #[derive(StarFrameProgram)]
 #[program(
@@ -65,29 +66,6 @@ impl StarFrameInstruction for ProcessEnlistPlayerIx {
             bump,
             _padding: [0; 5],
         };
-        <Init<Signer<MintAccount<'info>>>>::try_from_account_with_args(
-            &account_set.mint,
-            (),
-            Create(InitMint {
-                decimals: 0,
-                mint_authority: *account_set.player_account.key(),
-                freeze_authority: None,
-            }),
-            syscalls,
-        )?;
-        // AssociatedTokenProgram::cpi(
-        //     &associated_token::Create,
-        //     associated_token::CreateCpiAccounts {
-        //         funder: syscalls.get_funder().unwrap().account_info_cloned(),
-        //         // token_account: account_set.token_account.account_info_cloned(),
-        //         wallet: account_set.player_account.account_info_cloned(),
-        //         mint: account_set.mint.account_info_cloned(),
-        //         system_program: account_set.system_program.account_info_cloned(),
-        //         token_program: account_set.token_program.account_info_cloned(),
-        //     },
-        // )?
-        // .invoke(syscalls)?;
-
         Ok(())
     }
 }
@@ -112,18 +90,19 @@ pub struct ProcessEnlistPlayer<'info> {
     pub system_program: Program<'info, SystemProgram>,
     pub token_program: Program<'info, TokenProgram>,
     pub associated_token_program: Program<'info, AssociatedTokenProgram>,
-    pub mint: Signer<AccountInfo<'info>>,
-    // #[validate(arg = Create(InitMint {
-    //     decimals: 0,
-    //     mint_authority: *self.player_account.key(),
-    //     freeze_authority: None,
-    // }))]
-    // pub mint: Init<Signer<MintAccount<'info>>>,
-    // #[validate(arg = Create(InitTokenAccount {
-    //     mint: *self.mint.key(),
-    //     owner: *self.player_account.key(),
-    // }))]
-    // pub token_account: Init<Mut<TokenAccount<'info>>>,
+    #[validate(arg = Create(InitMint {
+        decimals: 0,
+        mint_authority: self.player_account.key(),
+        freeze_authority: Some(self.player_account.key()),
+    }))]
+    pub mint: Init<Signer<MintAccount<'info>>>,
+    #[validate(arg = Create(InitAta {
+        wallet: &self.player_account, 
+        mint: &self.mint, 
+        system_program: &self.system_program, 
+        token_program: &self.token_program
+    }))]
+    pub token_account: Init<AssociatedTokenAccount<'info>>,
 }
 
 #[derive(
@@ -178,7 +157,6 @@ mod tests {
     use solana_sdk::clock::Clock;
     use solana_sdk::signature::{Keypair, Signer};
     use star_frame::solana_program::native_token::LAMPORTS_PER_SOL;
-    use star_frame_spl::associated_token::AssociatedTokenProgram;
     use star_frame_spl::token::TokenProgram;
 
     #[cfg(feature = "idl")]
@@ -236,8 +214,8 @@ mod tests {
         let faction_id = FactionId::MUD;
 
         let mint_keypair = Keypair::new();
-        // let token_account =
-        //     AssociatedTokenProgram::find_address(&player_account.pubkey(), &mint_keypair.pubkey());
+        let token_account =
+            AssociatedTokenProgram::find_address(&player_account.pubkey(), &mint_keypair.pubkey());
 
         let ix = FactionEnlistment::instruction(
             &ProcessEnlistPlayerIx { bump, faction_id },
@@ -248,7 +226,7 @@ mod tests {
                 token_program: TokenProgram::PROGRAM_ID,
                 associated_token_program: AssociatedTokenProgram::PROGRAM_ID,
                 mint: mint_keypair.pubkey(),
-                // token_account,
+                token_account,
             },
         )?;
 
@@ -265,7 +243,7 @@ mod tests {
             .process_transaction_with_metadata(tx.clone())
             .await?;
 
-        println!("{:?}", txn);
+        println!("{:#?}", txn);
 
         let clock = banks_client.get_sysvar::<Clock>().await?;
         let expected_faction_account = PlayerFactionData {

framework/example_programs/faction_enlistment/src/lib.rs

@@ -27,6 +27,7 @@ solana-program = { workspace = true }
 star_frame_proc = { workspace = true }
 static_assertions = { workspace = true }
 typenum = { workspace = true }
+ref-cast.workspace = true
 
 # feature = idl
 serde = { workspace = true, features = ["derive"] }

framework/star_frame/Cargo.toml

@@ -125,11 +125,10 @@ where
 {
     /// Validates the owner and the discriminant of the account.
     pub fn validate(&self) -> Result<()> {
-        if self.info.owner != &T::OwnerProgram::PROGRAM_ID {
+        if self.owner() != &T::OwnerProgram::PROGRAM_ID {
             bail!(ProgramError::IllegalOwner);
         }
-        let data = self.info.try_borrow_data()?;
-
+        let data = self.info_data_bytes()?;
         Self::check_discriminant(&data)?;
         Ok(())
     }
@@ -146,10 +145,10 @@ where
     }
 
     pub fn data<'a>(&'a self) -> Result<RefWrapper<AccountInfoRef<'a>, T::RefData>> {
-        let r: Ref<'a, _> = self.info.try_borrow_data()?;
+        let r: Ref<'a, _> = self.info_data_bytes()?;
         Self::check_discriminant(&r)?;
         let r = try_map_ref(r, |bytes| {
-            let bytes = &mut &**bytes;
+            let bytes = &mut &*bytes;
             bytes.try_advance(size_of::<
                 <T::OwnerProgram as StarFrameProgram>::AccountDiscriminant,
             >())?;
@@ -162,7 +161,7 @@ where
     pub fn data_mut<'a>(
         &'a mut self,
     ) -> Result<RefWrapper<AccountInfoRefMut<'a, 'info, T::OwnerProgram>, T::RefData>> {
-        let r: RefMut<'a, _> = self.info.try_borrow_mut_data()?;
+        let r: RefMut<'a, _> = self.info_data_bytes_mut()?;
         Self::check_discriminant(&r)?;
         let account_info_ref_mut = AccountInfoRefMut {
             account_info: &self.info,
@@ -210,111 +209,63 @@ where
     type Seeds = T::Seeds;
 }
 
-impl<'info, T: ProgramAccount + UnsizedType + ?Sized> CanInitAccount<'info, CreateIfNeeded<()>>
+impl<'info, T: ProgramAccount + UnsizedType + ?Sized> CanInitAccount<'info, ()>
     for DataAccount<'info, T>
 where
     T: UnsizedInit<Zeroed>,
 {
-    fn init_account(
-        &mut self,
-        _arg: CreateIfNeeded<()>,
-        syscalls: &impl SyscallInvoke<'info>,
-        account_seeds: Option<Vec<&[u8]>>,
-    ) -> Result<()> {
-        self.init_account(CreateIfNeeded((Zeroed,)), syscalls, account_seeds)
-    }
-}
-
-impl<'info, T: ProgramAccount + UnsizedType + ?Sized, InitArg>
-    CanInitAccount<'info, CreateIfNeeded<(InitArg,)>> for DataAccount<'info, T>
-where
-    T: UnsizedInit<InitArg>,
-{
-    fn init_account(
+    fn init_account<const IF_NEEDED: bool>(
         &mut self,
-        arg: CreateIfNeeded<(InitArg,)>,
-        syscalls: &impl SyscallInvoke<'info>,
+        _arg: (),
         account_seeds: Option<Vec<&[u8]>>,
-    ) -> Result<()> {
-        let funder = syscalls
-            .get_funder()
-            .context("Missing `funder` for `CreateIfNeeded`")?;
-        self.init_account(CreateIfNeeded((arg.0 .0, funder)), syscalls, account_seeds)
-    }
-}
-
-impl<'info, T: ProgramAccount + UnsizedType + ?Sized, InitArg, Funder>
-    CanInitAccount<'info, CreateIfNeeded<(InitArg, &Funder)>> for DataAccount<'info, T>
-where
-    T: UnsizedInit<InitArg>,
-    Funder: SignedAccount<'info> + WritableAccount<'info>,
-{
-    fn init_account(
-        &mut self,
-        arg: CreateIfNeeded<(InitArg, &Funder)>,
         syscalls: &impl SyscallInvoke<'info>,
-        account_seeds: Option<Vec<&[u8]>>,
     ) -> Result<()> {
-        if self.owner() == &SystemProgram::PROGRAM_ID
-            || self.account_info().data.borrow_mut()
-                [..size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>()]
-                .iter()
-                .all(|x| *x == 0)
-        {
-            self.init_account(Create(arg.0), syscalls, account_seeds)?;
-        }
-        Ok(())
+        self.init_account::<IF_NEEDED>((Zeroed,), account_seeds, syscalls)
     }
 }
 
-impl<'info, T: ProgramAccount + UnsizedType + ?Sized> CanInitAccount<'info, Create<()>>
+impl<'info, T: ProgramAccount + UnsizedType + ?Sized, InitArg> CanInitAccount<'info, (InitArg,)>
     for DataAccount<'info, T>
-where
-    T: UnsizedInit<Zeroed>,
-{
-    fn init_account(
-        &mut self,
-        _arg: Create<()>,
-        syscalls: &impl SyscallInvoke<'info>,
-        account_seeds: Option<Vec<&[u8]>>,
-    ) -> Result<()> {
-        self.init_account(Create((Zeroed,)), syscalls, account_seeds)
-    }
-}
-
-impl<'info, T: ProgramAccount + UnsizedType + ?Sized, InitArg>
-    CanInitAccount<'info, Create<(InitArg,)>> for DataAccount<'info, T>
 where
     T: UnsizedInit<InitArg>,
 {
-    fn init_account(
+    fn init_account<const IF_NEEDED: bool>(
         &mut self,
-        arg: Create<(InitArg,)>,
-        syscalls: &impl SyscallInvoke<'info>,
+        arg: (InitArg,),
         account_seeds: Option<Vec<&[u8]>>,
+        syscalls: &impl SyscallInvoke<'info>,
     ) -> Result<()> {
         let funder = syscalls
             .get_funder()
-            .context("Missing `funder` for `Create`")?;
-        self.init_account(Create((arg.0 .0, funder)), syscalls, account_seeds)
+            .context("Missing tagged `funder` for DataAccount `init_account`")?;
+        self.init_account::<IF_NEEDED>((arg.0, funder), account_seeds, syscalls)
     }
 }
 
 impl<'info, T: ProgramAccount + UnsizedType + ?Sized, InitArg, Funder>
-    CanInitAccount<'info, Create<(InitArg, &Funder)>> for DataAccount<'info, T>
+    CanInitAccount<'info, (InitArg, &Funder)> for DataAccount<'info, T>
 where
     T: UnsizedInit<InitArg>,
     Funder: SignedAccount<'info> + WritableAccount<'info>,
 {
-    fn init_account(
+    fn init_account<const IF_NEEDED: bool>(
         &mut self,
-        arg: Create<(InitArg, &Funder)>,
-        syscalls: &impl SyscallInvoke<'info>,
+        arg: (InitArg, &Funder),
         account_seeds: Option<Vec<&[u8]>>,
+        syscalls: &impl SyscallInvoke<'info>,
     ) -> Result<()> {
-        self.check_writable()
-            .context("InitAccount must be writable")?;
-        let (arg, funder) = arg.0;
+        if IF_NEEDED {
+            let needs_init = self.owner() == &SystemProgram::PROGRAM_ID
+                || self.info_data_bytes()?
+                    [..size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>()]
+                    .iter()
+                    .all(|x| *x == 0);
+            if !needs_init {
+                return Ok(());
+            }
+        }
+        self.check_writable()?;
+        let (arg, funder) = arg;
         let size =
             T::INIT_BYTES + size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>();
         self.system_create_account(