Merge pull request #64 from staratlasmeta/stegaBOB/fix/stuff

Fix: stuff

Author: stegaBOB

framework/example_programs/counter/src/lib.rs

@@ -56,27 +56,22 @@ impl StarFrameInstruction for CreateCounterIx {
     type RunArg<'a> = &'a Option<u64>;
     type CleanupArg<'a> = ();
     type ReturnType = ();
-    type Accounts<'b, 'c, 'info> = CreateCounterAccounts<'info>
-    where
-        'info: 'b;
+    type Accounts<'b, 'c, 'info> = CreateCounterAccounts<'info>;
 
-    fn split_to_args<'a>(r: &Self) -> SplitToArgsReturn<Self> {
-        SplitToArgsReturn {
+    fn split_to_args<'a>(r: &Self) -> IxArgs<Self> {
+        IxArgs {
             decode: (),
             cleanup: (),
             run: &r.start_at,
             validate: (),
         }
     }
 
-    fn run_instruction<'b, 'info>(
-        account_set: &mut Self::Accounts<'b, '_, 'info>,
+    fn run_instruction(
+        account_set: &mut Self::Accounts<'_, '_, '_>,
         start_at: Self::RunArg<'_>,
         _syscalls: &mut impl SyscallInvoke,
-    ) -> Result<Self::ReturnType>
-    where
-        'info: 'b,
-    {
+    ) -> Result<Self::ReturnType> {
         *account_set.counter.data_mut()? = CounterAccount {
             version: 0,
             signer: *account_set.owner.key(),
@@ -115,24 +110,19 @@ impl StarFrameInstruction for UpdateCounterSignerIx {
     type RunArg<'a> = ();
     type CleanupArg<'a> = ();
     type ReturnType = ();
-    type Accounts<'b, 'c, 'info> = UpdateCounterSignerAccounts<'info>
-    where
-        'info: 'b;
+    type Accounts<'b, 'c, 'info> = UpdateCounterSignerAccounts<'info>;
 
-    fn split_to_args<'a>(_r: &Self) -> SplitToArgsReturn<Self> {
-        SplitToArgsReturn {
+    fn split_to_args<'a>(_r: &Self) -> IxArgs<Self> {
+        IxArgs {
             ..Default::default()
         }
     }
 
-    fn run_instruction<'b, 'info>(
-        account_set: &mut Self::Accounts<'b, '_, 'info>,
+    fn run_instruction(
+        account_set: &mut Self::Accounts<'_, '_, '_>,
         _run_args: Self::RunArg<'_>,
         _syscalls: &mut impl SyscallInvoke,
-    ) -> Result<Self::ReturnType>
-    where
-        'info: 'b,
-    {
+    ) -> Result<Self::ReturnType> {
         let mut counter = account_set.counter.data_mut()?;
         counter.signer = *account_set.new_signer.key();
 
@@ -168,25 +158,20 @@ impl StarFrameInstruction for CountIx {
     type RunArg<'a> = (u64, bool);
     type CleanupArg<'a> = ();
     type ReturnType = ();
-    type Accounts<'b, 'c, 'info> = CountAccounts<'info>
-    where
-        'info: 'b;
+    type Accounts<'b, 'c, 'info> = CountAccounts<'info>;
 
-    fn split_to_args<'a>(r: &Self) -> SplitToArgsReturn<Self> {
-        SplitToArgsReturn {
+    fn split_to_args<'a>(r: &Self) -> IxArgs<Self> {
+        IxArgs {
             run: (r.amount, r.subtract),
             ..Default::default()
         }
     }
 
-    fn run_instruction<'b, 'info>(
-        account_set: &mut Self::Accounts<'b, '_, 'info>,
+    fn run_instruction(
+        account_set: &mut Self::Accounts<'_, '_, '_>,
         (amount, subtract): Self::RunArg<'_>,
         _syscalls: &mut impl SyscallInvoke,
-    ) -> Result<Self::ReturnType>
-    where
-        'info: 'b,
-    {
+    ) -> Result<Self::ReturnType> {
         let mut counter = account_set.counter.data_mut()?;
         let new_count: u64 = if subtract {
             counter.count - amount
@@ -228,24 +213,17 @@ impl StarFrameInstruction for CloseCounterIx {
     type RunArg<'a> = ();
     type CleanupArg<'a> = ();
     type ReturnType = ();
-    type Accounts<'b, 'c, 'info> = CloseCounterAccounts<'info>
-    where
-        'info: 'b;
+    type Accounts<'b, 'c, 'info> = CloseCounterAccounts<'info>;
 
-    fn split_to_args<'a>(_r: &Self) -> SplitToArgsReturn<Self> {
-        SplitToArgsReturn {
-            ..Default::default()
-        }
+    fn split_to_args<'a>(_r: &Self) -> IxArgs<Self> {
+        Default::default()
     }
 
-    fn run_instruction<'b, 'info>(
-        _account_set: &mut Self::Accounts<'b, '_, 'info>,
+    fn run_instruction(
+        _account_set: &mut Self::Accounts<'_, '_, '_>,
         _run_args: Self::RunArg<'_>,
         _syscalls: &mut impl SyscallInvoke,
-    ) -> Result<Self::ReturnType>
-    where
-        'info: 'b,
-    {
+    ) -> Result<Self::ReturnType> {
         Ok(())
     }
 }

framework/example_programs/faction_enlistment/src/lib.rs

@@ -42,12 +42,11 @@ impl StarFrameInstruction for ProcessEnlistPlayerIx {
     type ReturnType = ();
     // type RunArg<'a> = (FactionId, &'a Vec<u8>);
     type RunArg<'a> = FactionId;
-    type Accounts<'b, 'c, 'info> = ProcessEnlistPlayer<'info>
-        where 'info: 'b;
+    type Accounts<'b, 'c, 'info> = ProcessEnlistPlayer<'info>;
     // type ReturnType = usize;
 
-    fn split_to_args<'a>(r: &Self) -> SplitToArgsReturn<Self> {
-        SplitToArgsReturn {
+    fn split_to_args<'a>(r: &Self) -> IxArgs<Self> {
+        IxArgs {
             validate: r.bump,
             run: r.faction_id,
             // run: (r.faction_id, &r.buncha_data),
@@ -56,14 +55,11 @@ impl StarFrameInstruction for ProcessEnlistPlayerIx {
         }
     }
 
-    fn run_instruction<'b, 'info>(
-        account_set: &mut Self::Accounts<'b, '_, 'info>,
+    fn run_instruction(
+        account_set: &mut Self::Accounts<'_, '_, '_>,
         faction_id: Self::RunArg<'_>,
         syscalls: &mut impl SyscallInvoke,
-    ) -> Result<Self::ReturnType>
-    where
-        'info: 'b,
-    {
+    ) -> Result<Self::ReturnType> {
         let clock = syscalls.get_clock()?;
 
         let bump = account_set.player_faction_account.access_seeds().bump;

framework/star_frame/src/account_set/data_account.rs

@@ -17,27 +17,6 @@ pub trait ProgramAccount {
     const DISCRIMINANT: <Self::OwnerProgram as StarFrameProgram>::AccountDiscriminant;
 }
 
-fn validate_data_account<T>(account: &DataAccount<T>, _syscalls: &impl SyscallCore) -> Result<()>
-where
-    T: ProgramAccount + UnsizedType + ?Sized,
-{
-    if account.info.owner != &T::OwnerProgram::PROGRAM_ID {
-        bail!(ProgramError::IllegalOwner);
-    }
-
-    let data = account.info.try_borrow_data()?;
-    if data.len() < size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>() {
-        bail!(ProgramError::InvalidAccountData);
-    }
-    let discriminant: &<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant = from_bytes(
-        &data[0..size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>()],
-    );
-    if discriminant != &T::DISCRIMINANT {
-        bail!(ProgramError::InvalidAccountData);
-    }
-    Ok(())
-}
-
 #[derive(Debug, Derivative)]
 #[derivative(Copy(bound = ""), Clone(bound = ""))]
 pub struct NormalizeRent<'a, 'info, F> {
@@ -56,7 +35,15 @@ pub struct CloseAccount<'a, F> {
 }
 
 #[derive(AccountSet, Debug)]
-#[validate(extra_validation = validate_data_account(self, syscalls))]
+#[validate(extra_validation = self.validate())]
+#[validate(
+    id = "address", 
+    arg = &Pubkey,
+    extra_validation = {
+        anyhow::ensure!(self.key() == arg);
+        self.validate()
+    }
+)]
 #[cleanup(extra_cleanup = self.check_cleanup(syscalls))]
 #[cleanup(
     id = "normalize_rent",
@@ -85,6 +72,17 @@ impl<'info, T> DataAccount<'info, T>
 where
     T: ProgramAccount + UnsizedType + ?Sized,
 {
+    /// Validates the owner and the discriminant of the account.
+    fn validate(&self) -> Result<()> {
+        if self.info.owner != &T::OwnerProgram::PROGRAM_ID {
+            bail!(ProgramError::IllegalOwner);
+        }
+        let data = self.info.try_borrow_data()?;
+
+        Self::check_discriminant(&data)?;
+        Ok(())
+    }
+
     fn check_discriminant(bytes: &[u8]) -> Result<()> {
         if bytes.len() < size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>()
             || from_bytes::<PackedValue<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>>(
@@ -123,7 +121,8 @@ where
         T::from_bytes(account_info_ref_mut).map(|ret| ret.ref_wrapper)
     }
 
-    /// Closes the account
+    /// Closes the account by zeroing the lamports and leaving the data as the
+    /// [`StarFrameProgram::CLOSED_ACCOUNT_DISCRIMINANT`], reallocating down to size.
     pub fn close(&mut self, recipient: &impl WritableAccount<'info>) -> Result<()> {
         self.info.realloc(
             size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>(),
@@ -137,8 +136,8 @@ where
         Ok(())
     }
 
-    /// Closes the account by reallocing and transfering. This is the same as calling `close` but
-    /// not abusable and harder for indexer detection.
+    /// Closes the account by reallocating to zero and assigning to the System program.
+    /// This is the same as calling `close` but not abusable and harder for indexer detection.
     pub fn close_full(&mut self, recipient: &impl WritableAccount<'info>) -> Result<()> {
         self.info.realloc(
             size_of::<<T::OwnerProgram as StarFrameProgram>::AccountDiscriminant>(),
@@ -154,6 +153,7 @@ where
         Ok(())
     }
 
+    /// See [`normalize_rent`]
     pub fn normalize_rent(
         &mut self,
         funder: &(impl WritableAccount<'info> + SignedAccount<'info>),
@@ -163,6 +163,7 @@ where
         normalize_rent(self.account_info(), funder, system_program, syscalls)
     }
 
+    /// See [`refund_rent`]
     pub fn refund_rent(
         &mut self,
         recipient: &impl WritableAccount<'info>,
@@ -171,34 +172,21 @@ where
         refund_rent(self.account_info(), recipient, sys_calls)
     }
 
+    /// Emits a warning message if the account has more lamports than required by rent.
     pub fn check_cleanup(&self, sys_calls: &mut impl SyscallCore) -> Result<()> {
         #[cfg(feature = "cleanup_rent_warning")]
         {
-            use anyhow::Context;
             use std::cmp::Ordering;
             if self.is_writable() {
                 let rent = sys_calls.get_rent()?;
                 let lamports = self.account_info().lamports();
                 let data_len = self.account_info().data_len();
                 let rent_lamports = rent.minimum_balance(data_len);
-                match rent_lamports.cmp(&lamports) {
-                    Ordering::Greater => {
-                        // is this more descriptive than just letting the runtime error out?
-                        return Err(anyhow::anyhow!(ProgramError::AccountNotRentExempt))
-                            .with_context(|| {
-                                format!(
-                                    "{} was left with less lamports than required by rent",
-                                    self.key()
-                                )
-                            });
-                    }
-                    Ordering::Less => {
-                        msg!(
-                            "{} was left with more lamports than required by rent",
-                            self.key()
-                        );
-                    }
-                    Ordering::Equal => {}
+                if rent_lamports.cmp(&lamports) == Ordering::Less {
+                    msg!(
+                        "{} was left with more lamports than required by rent",
+                        self.key()
+                    );
                 }
             }
         }

framework/star_frame/src/data_types/mod.rs

@@ -5,11 +5,13 @@ mod key_for;
 mod optional_key_for;
 mod packed_value;
 mod pod_bool;
+mod remaining_data;
 mod unit_val;
 
 pub use divisor::*;
 pub use key_for::*;
 pub use optional_key_for::*;
 pub use packed_value::*;
 pub use pod_bool::*;
+pub use remaining_data::*;
 pub use unit_val::*;

framework/star_frame/src/data_types/remaining_data.rs

@@ -0,0 +1,25 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use derive_more::{Deref, DerefMut, From, Into};
+use std::io::{Read, Write};
+
+/// A helper struct for Borsh that consumes the remaining bytes in a buffer. This is most useful for replicating remaining
+/// data in an instruction without the 4 byte length overhead for [`borsh`]'s serialize and deserialize on `Vec`.
+#[derive(
+    Debug, Clone, PartialEq, Eq, Deref, DerefMut, Default, Hash, Ord, PartialOrd, From, Into,
+)]
+#[repr(transparent)]
+pub struct RemainingData(Vec<u8>);
+
+impl BorshDeserialize for RemainingData {
+    fn deserialize_reader<R: Read>(reader: &mut R) -> std::io::Result<Self> {
+        let mut data = vec![];
+        reader.read_to_end(&mut data)?;
+        Ok(Self(data))
+    }
+}
+
+impl BorshSerialize for RemainingData {
+    fn serialize<W: Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        writer.write_all(&self.0)
+    }
+}

framework/star_frame/src/entrypoint.rs

@@ -1,5 +1,5 @@
 /// Macro to define the entrypoint for a `star_frame` program. This wraps the default [`solana_program::entrypoint!`] macro
-/// and only needs to take in the [`StarFrameProgram`] type. This will be automatically called by the
+/// and only needs to take in the [`StarFrameProgram`](crate::prelude::StarFrameProgram) type. This will be automatically called by the
 /// [`StarFrameProgram`](star_frame_proc::StarFrameProgram) derive macro if the `no_entrypoint` argument
 /// is not present.
 ///