Merge pull request #74 from AdrenaFoundation/release-next

Prepare next release

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "cSpell.words": [
+        "pdas",
+        "RUSTC",
+        "Sablier",
+        "pubkey",
+        "solana",
+        "lamports"
+    ]
+}

plugin/src/executors/state/executable_threads.rs

@@ -10,7 +10,7 @@ use tokio::sync::RwLock;
 use crate::{executors::tx::ExecutableThreadMetadata, pool_position::PoolPosition};
 
 /// Number of times to retry a thread simulation.
-static MAX_THREAD_SIMULATION_FAILURES: u32 = 10;
+static MAX_THREAD_SIMULATION_FAILURES: u32 = 5;
 
 /// Number of slots to wait before trying to execute a thread while not in the pool.
 static THREAD_TIMEOUT_WINDOW: u64 = 24;

programs/thread/src/errors.rs

@@ -43,4 +43,12 @@ pub enum SablierError {
     /// Thrown if the user attempts to withdraw SOL that would put a thread below it's minimum rent threshold.
     #[msg("Withdrawing this amount would leave the thread with less than the minimum required SOL for rent exemption")]
     WithdrawalTooLarge,
+
+    /// Thrown if the provided authority does not match the thread's authority.
+    #[msg("The provided authority does not match the thread's authority")]
+    InvalidThreadAuthority,
+
+    /// Thrown if the provided account is not a valid Thread account.
+    #[msg("The provided thread account is not a valid Thread account")]
+    InvalidThreadAccount,
 }

programs/thread/src/instructions/thread_create.rs

@@ -30,7 +30,7 @@ pub struct ThreadCreate<'info> {
             domain.as_ref().unwrap_or(&Vec::new()).as_slice()
         ],
         bump,
-        payer= payer,
+        payer = payer,
         space = Thread::min_space(&instructions)?
     )]
     pub thread: Account<'info, Thread>,

programs/thread/src/instructions/thread_delete.rs

@@ -1,42 +1,92 @@
 use {
-    crate::{constants::*, state::*},
-    anchor_lang::prelude::*,
+    crate::{constants::SEED_THREAD, errors::SablierError, state::*},
+    anchor_lang::{prelude::*, solana_program::system_program},
 };
 
 /// Accounts required by the `thread_delete` instruction.
 #[derive(Accounts)]
 pub struct ThreadDelete<'info> {
     /// The authority (owner) of the thread.
-    #[account(
-        constraint = authority.key().eq(&thread.authority) || authority.key().eq(&thread.key())
-    )]
     pub authority: Signer<'info>,
 
     /// The address to return the data rent lamports to.
     #[account(mut)]
     pub close_to: SystemAccount<'info>,
 
-    /// The thread to be delete.
-    #[account(
-        mut,
-        seeds = [
-            SEED_THREAD,
-            thread.authority.as_ref(),
-            thread.id.as_slice(),
-            thread.domain.as_ref().unwrap_or(&Vec::new()).as_slice()
-        ],
-        bump = thread.bump,
-    )]
-    pub thread: Account<'info, Thread>,
+    /// The thread to be deleted.
+    /// CHECK: Validation checks are performed during instruction processing.
+    #[account(mut)]
+    pub thread: UncheckedAccount<'info>,
 }
 
 pub fn handler(ctx: Context<ThreadDelete>) -> Result<()> {
     let thread = &ctx.accounts.thread;
     let close_to = &ctx.accounts.close_to;
 
-    let thread_lamports = thread.get_lamports();
-    thread.sub_lamports(thread_lamports)?;
-    close_to.add_lamports(thread_lamports)?;
+    // We want this instruction not to fail if the thread is already deleted or inexistent.
+    // As such, all checks are done in the code that than in anchor (see commented code above)
+    // First, must try to deserialize the thread.
+
+    // Get either V1 or V2 thread - If the provided thread does not exist, print an error message and return Ok.
+    let thread = match Thread::try_deserialize_unchecked(&mut thread.data.borrow_mut().as_ref()) {
+        Ok(t) => t,
+        Err(_) => {
+            msg!("Not a thread or account does not exist");
+            return Ok(());
+        }
+    };
+
+    // Preliminary checks
+    {
+        // Verify the authority
+        let authority_key = ctx.accounts.authority.key;
+        let thread_key = ctx.accounts.thread.key;
+
+        require!(
+            thread.authority.eq(authority_key) || authority_key.eq(thread_key),
+            SablierError::InvalidThreadAuthority
+        );
+
+        // Verify the account provided
+        let thread_account = &ctx.accounts.thread;
+        {
+            // Verify the account is initialized
+            require!(
+                thread_account.owner != &system_program::ID && thread_account.lamports() > 0,
+                SablierError::InvalidThreadAccount
+            );
+
+            // Verify the account is owned by the program
+            require!(
+                thread_account.owner == &crate::ID,
+                SablierError::InvalidThreadAccount
+            );
+
+            // Verify the seed derivation
+            let default_vec = Vec::new();
+            let thread_bump = thread.bump.to_le_bytes();
+            let seed = [
+                SEED_THREAD,
+                thread.authority.as_ref(),
+                thread.id.as_slice(),
+                thread.domain.as_ref().unwrap_or(&default_vec).as_slice(),
+                thread_bump.as_ref(),
+            ];
+            let expected_thread_key = Pubkey::create_program_address(&seed, &crate::ID)
+                .map_err(|_| SablierError::InvalidThreadAccount)?;
+            require!(
+                expected_thread_key == *thread_key,
+                SablierError::InvalidThreadAccount
+            );
+        }
+    }
 
+    // Transfer lamports out (implicit close)
+    {
+        let thread_account = &ctx.accounts.thread;
+        let thread_lamports = thread_account.get_lamports();
+        thread_account.sub_lamports(thread_lamports)?;
+        close_to.add_lamports(thread_lamports)?;
+    }
     Ok(())
 }

programs/thread/src/instructions/thread_exec.rs

@@ -204,5 +204,28 @@ pub fn handler(ctx: Context<ThreadExec>) -> Result<()> {
         fee.add_lamports(thread.fee)?;
     }
 
+    let exec_ctx = &mut thread.exec_context.unwrap();
+
+    // Update execution context for Cron and Periodic triggers
+    // This ensures the next execution is scheduled based on the actual execution time,
+    // rather than the theoretical scheduled time, preventing drift in long-running threads
+    match thread.trigger {
+        Trigger::Cron { skippable, .. } => {
+            if skippable {
+                exec_ctx.last_exec_at = clock.slot;
+                exec_ctx.trigger_context = TriggerContext::Cron {
+                    started_at: clock.unix_timestamp,
+                };
+            }
+        }
+        Trigger::Periodic { .. } => {
+            exec_ctx.last_exec_at = clock.slot;
+            exec_ctx.trigger_context = TriggerContext::Periodic {
+                started_at: clock.unix_timestamp,
+            };
+        }
+        _ => (),
+    }
+
     Ok(())
 }

programs/thread/src/state/thread.rs

@@ -71,8 +71,12 @@ pub trait ThreadAccount {
 
 impl Thread {
     pub fn min_space(instructions: &[SerializableInstruction]) -> Result<usize> {
-        let ins_number = instructions.len();
         let ins_space = instructions.try_to_vec()?.len();
+        let max_ins_size = instructions
+            .iter()
+            .map(|ins| ins.try_to_vec().map(|v| v.len()).unwrap_or(0))
+            .max()
+            .unwrap_or(0);
 
         Ok(
             8
@@ -84,7 +88,7 @@ impl Thread {
             + u64::MIN_SPACE // fee
             + (4 + 32) // id
             + (4 + ins_space) // instructions
-            + (1 + ins_space / ins_number) // next_instruction
+            + (1 + max_ins_size) // next_instruction
             + bool::MIN_SPACE // paused
             + u64::MIN_SPACE // rate_limit
             + Trigger::MIN_SPACE, // trigger