cronos_scheduler/instructions/
task_exec.rs

1use {
2    crate::{errors::CronosError, events::TaskExecuted, instructions::utils::is_spam, state::*},
3    anchor_lang::{prelude::*, solana_program::sysvar, system_program},
4    cronos_pool::state::Pool
5};
6
7#[derive(Accounts)]
8pub struct TaskExec<'info> {
9    #[account(address = sysvar::clock::ID)]
10    pub clock: Sysvar<'info, Clock>,
11
12    #[account(seeds = [SEED_CONFIG], bump)]
13    pub config: Box<Account<'info, Config>>,
14
15    #[account(mut)]
16    pub delegate: Signer<'info>,
17
18    #[account(
19        mut,
20        seeds = [
21            SEED_FEE,
22            queue.key().as_ref()
23        ],
24        bump,
25        has_one = queue
26    )]
27    pub fee: Account<'info, Fee>,
28
29    #[account(seeds = [SEED_MANAGER, manager.authority.as_ref()], bump)]
30    pub manager: Account<'info, Manager>,
31
32    #[account()]
33    pub pool: Account<'info, Pool>,
34
35    #[account(
36        mut,
37        seeds = [
38            SEED_QUEUE, 
39            queue.manager.as_ref(),
40            queue.id.to_be_bytes().as_ref(),
41        ],
42        bump,
43        constraint = match queue.status {
44            QueueStatus::Processing { task_id } => task_id == task.id,
45            _ => false,
46        } @ CronosError::InvalidQueueStatus
47    )]
48    pub queue: Account<'info, Queue>,
49
50    #[account(address = system_program::ID)]
51    pub system_program: Program<'info, System>,
52
53    #[account(
54        mut,
55        seeds = [
56            SEED_TASK,
57            task.queue.as_ref(),
58            task.id.to_be_bytes().as_ref()
59        ],
60        bump,
61    )]
62    pub task: Account<'info, Task>,
63}
64
65pub fn handler(ctx: Context<TaskExec>) -> Result<()> {
66    let task = &mut ctx.accounts.task;
67    let clock = &ctx.accounts.clock;
68    let config = &ctx.accounts.config;
69    let delegate = &mut ctx.accounts.delegate;
70    let fee = &mut ctx.accounts.fee;
71    let manager = &ctx.accounts.manager;
72    let pool = &ctx.accounts.pool;
73    let queue = &mut ctx.accounts.queue;
74    let system_program = &ctx.accounts.system_program;
75
76    // Validate the delegate is authorized to execute this task
77    if is_spam(clock, &config, delegate, fee, pool, queue, system_program)? {
78        return Ok(());
79    }
80
81    let account_infos = &mut ctx.remaining_accounts.clone().to_vec();
82
83    let manager_bump = *ctx.bumps.get("manager").unwrap();
84    task.exec(account_infos, config, delegate, fee, manager, manager_bump, queue)?;
85
86    emit!(TaskExecuted {
87        delegate: delegate.key(),
88        queue: queue.key(),
89        task: task.key(),
90        ts: clock.unix_timestamp,
91    });
92
93    Ok(())
94}