Attempting to work through CPI rescheduling

Author: ChewingGlass

solana-programs/Anchor.toml

@@ -6,10 +6,12 @@ skip-lint = false
 
 [programs.localnet]
 tuktuk = "tukpKuBbnQwG6yQbYRbeDM9Dk3D9fDkUpc6sytJsyGC"
+cpi-example = "cpic9j9sjqvhn2ZX3mqcCgzHKCwiiBTyEszyCwN7MBC"
 
 [workspace]
 members = [
-  "programs/tuktuk"
+  "programs/tuktuk",
+  "programs/cpi-example"
 ]
 
 [registry]

solana-programs/packages/tuktuk-sdk/src/transaction.ts

@@ -1,11 +1,16 @@
-import { CustomAccountResolver, Idl, IdlTypes, Program } from "@coral-xyz/anchor";
+import {
+  CustomAccountResolver,
+  Idl,
+  IdlTypes,
+  Program,
+} from "@coral-xyz/anchor";
 import { Tuktuk } from "@helium/tuktuk-idls/lib/types/tuktuk";
 import {
   AccountMeta,
   PublicKey,
   TransactionInstruction,
 } from "@solana/web3.js";
-import { customSignerKey, tuktukConfigKey } from "./pdas";
+import { customSignerKey, taskKey, tuktukConfigKey } from "./pdas";
 import { getAssociatedTokenAddressSync } from "@solana/spl-token";
 
 export type CompiledTransactionArgV0 =
@@ -17,7 +22,7 @@ export type CustomAccountResolverFactory<T extends Idl> = (
 
 export function compileTransaction(
   instructions: TransactionInstruction[],
-  signerSeeds: Buffer[][]
+  signerSeeds: Buffer[][],
 ): { transaction: CompiledTransactionArgV0; remainingAccounts: AccountMeta[] } {
   let pubkeysToMetadata: Record<
     string,
@@ -110,6 +115,25 @@ export function compileTransaction(
   };
 }
 
+function nextAvailableTaskIds(taskBitmap: Buffer, n: number): number[] {
+  const availableTaskIds: number[] = [];
+  for (let byteIdx = 0; byteIdx < taskBitmap.length; byteIdx++) {
+    const byte = taskBitmap[byteIdx];
+    if (byte !== 0xff) {
+      // If byte is not all 1s
+      for (let bitIdx = 0; bitIdx < 8; bitIdx++) {
+        if ((byte & (1 << bitIdx)) === 0) {
+          availableTaskIds.push(byteIdx * 8 + bitIdx);
+          if (availableTaskIds.length === n) {
+            return availableTaskIds;
+          }
+        }
+      }
+    }
+  }
+  return availableTaskIds;
+}
+
 export async function runTask({
   program,
   task,
@@ -121,8 +145,11 @@ export async function runTask({
 }) {
   const {
     taskQueue,
+    freeTasks,
     transaction: { numRwSigners, numRoSigners, numRw, accounts, signerSeeds },
   } = await program.account.taskV0.fetch(task);
+  const taskQueueAcc = await program.account.taskQueueV0.fetch(taskQueue);
+
   const configAcc = await program.account.tuktukConfigV0.fetch(
     tuktukConfigKey()[0]
   );
@@ -137,15 +164,24 @@ export async function runTask({
       isSigner: false,
     };
   });
+  const nextAvailable = nextAvailableTaskIds(
+    taskQueueAcc.taskBitmap,
+    freeTasks
+  );
+  const freeTasksAccounts = nextAvailable.map((id) => ({
+    pubkey: taskKey(taskQueue, id)[0],
+    isWritable: true,
+    isSigner: false,
+  }));
 
   return program.methods
     .runTaskV0()
     .accounts({
       task,
       rewardsDestination: getAssociatedTokenAddressSync(
         configAcc.networkMint,
-        rewardsDestinationWallet,
+        rewardsDestinationWallet
       ),
     })
-    .remainingAccounts(remainingAccounts);
+    .remainingAccounts([...remainingAccounts, ...freeTasksAccounts]);
 }

solana-programs/programs/cpi-example/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "cpi-example"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "cpi_example"
+
+[features]
+default = []
+cpi = ["no-entrypoint"]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]
+
+[dependencies]
+anchor-lang = { workspace = true, features = ["init-if-needed"] }
+anchor-spl = { workspace = true }
+tuktuk-sdk = { path = "../../../tuktuk-sdk" }

solana-programs/programs/cpi-example/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

solana-programs/programs/cpi-example/src/lib.rs

@@ -0,0 +1,87 @@
+use anchor_lang::prelude::*;
+use tuktuk_sdk::tuktuk::{tuktuk::program::Tuktuk, TaskQueueV0};
+
+declare_id!("cpic9j9sjqvhn2ZX3mqcCgzHKCwiiBTyEszyCwN7MBC");
+
+#[program]
+pub mod cpi_example {
+    use anchor_lang::{solana_program::instruction::Instruction, InstructionData};
+    use tuktuk_sdk::{
+        compiled_transaction::*,
+        tuktuk::{
+            tuktuk::cpi::{accounts::QueueTaskV0, queue_task_v0},
+            types::{QueueTaskArgsV0, TriggerV0},
+        },
+    };
+
+    use super::*;
+
+    pub fn schedule_next(ctx: Context<ScheduleNext>) -> Result<()> {
+        let my_tx = CpiContext::new(
+            ctx.accounts.system_program.to_account_info(),
+            crate::__cpi_client_accounts_schedule_next::ScheduleNext {
+                queue_authority: ctx.accounts.queue_authority.to_account_info(),
+                system_program: ctx.accounts.system_program.to_account_info(),
+                tuktuk_program: ctx.accounts.tuktuk_program.to_account_info(),
+                task_queue: ctx.accounts.task_queue.to_account_info(),
+                free_task_1: ctx.accounts.free_task_1.to_account_info(),
+            },
+        );
+        // Only take the first 3 accounts. Tuktuk will pass the task queue and a free task account automatically.
+        // We do this because we don't actually know what the task ID will be since its PDA depends on the available task ID.
+        let account_metas = my_tx.accounts.to_account_metas(None)[..3].to_vec();
+        let data = crate::instruction::ScheduleNext.data();
+        let (compiled_tx, _) = compile_transaction(
+            vec![Instruction {
+                program_id: crate::ID,
+                accounts: account_metas,
+                data,
+            }],
+            vec![],
+        )
+        .unwrap();
+
+        queue_task_v0(
+            CpiContext::new_with_signer(
+                ctx.accounts.tuktuk_program.to_account_info(),
+                QueueTaskV0 {
+                    payer: ctx.accounts.queue_authority.to_account_info(),
+                    queue_authority: ctx.accounts.queue_authority.to_account_info(),
+                    task_queue: ctx.accounts.task_queue.to_account_info(),
+                    task: ctx.accounts.free_task_1.to_account_info(),
+                    system_program: ctx.accounts.system_program.to_account_info(),
+                },
+                &[&[b"queue_authority".as_ref(), &[ctx.bumps.queue_authority]]],
+            )
+            .with_remaining_accounts(vec![
+                ctx.accounts.queue_authority.to_account_info(),
+                ctx.accounts.system_program.to_account_info(),
+                ctx.accounts.tuktuk_program.to_account_info(),
+            ]),
+            QueueTaskArgsV0 {
+                id: ctx.accounts.task_queue.next_available_task_id().unwrap() as u16,
+                // 5 seconds from now
+                trigger: TriggerV0::Timestamp(Clock::get()?.unix_timestamp + 5),
+                transaction: compiled_tx.into(),
+                crank_reward: None,
+                free_tasks: 1,
+            },
+        )?;
+        Ok(())
+    }
+}
+
+#[derive(Accounts)]
+pub struct ScheduleNext<'info> {
+    #[account(
+        mut,
+        seeds = [b"queue_authority".as_ref()],
+        bump,
+    )]
+    pub queue_authority: AccountInfo<'info>,
+    pub system_program: Program<'info, System>,
+    pub tuktuk_program: Program<'info, Tuktuk>,
+    pub task_queue: Account<'info, TaskQueueV0>,
+    /// CHECK: free task account
+    pub free_task_1: UncheckedAccount<'info>,
+}

solana-programs/programs/tuktuk/src/error.rs

@@ -16,4 +16,6 @@ pub enum ErrorCode {
     TaskNotReady,
     #[msg("Task queue not empty")]
     TaskQueueNotEmpty,
+    #[msg("Free task account not empty")]
+    FreeTaskAccountNotEmpty,
 }

solana-programs/programs/tuktuk/src/instructions/queue_task_v0.rs

@@ -12,6 +12,9 @@ pub struct QueueTaskArgsV0 {
     pub trigger: TriggerV0,
     pub transaction: CompiledTransactionArgV0,
     pub crank_reward: Option<u64>,
+    // Number of free tasks to append to the end of the accounts. This allows
+    // you to easily add new tasks
+    pub free_tasks: u8,
 }
 
 #[derive(AnchorSerialize, AnchorDeserialize, Clone, Default)]
@@ -32,7 +35,7 @@ pub struct CompiledTransactionArgV0 {
 
 #[derive(Accounts)]
 #[instruction(args: QueueTaskArgsV0)]
-pub struct QueuetaskV0<'info> {
+pub struct QueueTaskV0<'info> {
     #[account(mut)]
     pub payer: Signer<'info>,
     pub queue_authority: Signer<'info>,
@@ -54,8 +57,9 @@ pub struct QueuetaskV0<'info> {
     pub system_program: Program<'info, System>,
 }
 
-pub fn handler(ctx: Context<QueuetaskV0>, args: QueueTaskArgsV0) -> Result<()> {
+pub fn handler(ctx: Context<QueueTaskV0>, args: QueueTaskArgsV0) -> Result<()> {
     ctx.accounts.task.set_inner(TaskV0 {
+        free_tasks: args.free_tasks,
         task_queue: ctx.accounts.task_queue.key(),
         id: args.id,
         trigger: args.trigger,

solana-programs/programs/tuktuk/src/instructions/run_task_v0.rs

@@ -93,9 +93,22 @@ pub fn handler(ctx: Context<RunTaskV0>) -> Result<()> {
             ErrorCode::InvalidAccount
         );
     }
+
+    // Validate that all free task accounts are empty
+    let free_tasks_start_index = transaction.accounts.len();
+    for i in 0..ctx.accounts.task.free_tasks {
+        let free_task_index = free_tasks_start_index + i as usize;
+        let free_task_account = &ctx.remaining_accounts[free_task_index];
+        require!(
+            free_task_account.data_is_empty(),
+            ErrorCode::FreeTaskAccountNotEmpty
+        );
+    }
+
     for ix in &transaction.instructions {
         let mut accounts = Vec::new();
         let mut account_infos = Vec::new();
+
         for i in &ix.accounts {
             let acct = ctx.remaining_accounts[*i as usize].clone();
             accounts.push(acct.clone());
@@ -105,6 +118,25 @@ pub fn handler(ctx: Context<RunTaskV0>) -> Result<()> {
                 is_writable: acct.is_writable,
             })
         }
+
+        // Add task_queue and free tasks at the end
+        account_infos.push(AccountMeta {
+            pubkey: ctx.accounts.task_queue.key(),
+            is_signer: false,
+            is_writable: true,
+        });
+
+        // Add free tasks accounts, starting from the correct index
+        for i in 0..ctx.accounts.task.free_tasks {
+            let free_task_index = free_tasks_start_index + i as usize;
+            let acct = ctx.remaining_accounts[free_task_index].clone();
+            account_infos.push(AccountMeta {
+                pubkey: acct.key(),
+                is_signer: false,
+                is_writable: true,
+            });
+        }
+
         solana_program::program::invoke_signed(
             &Instruction {
                 program_id: *ctx.remaining_accounts[ix.program_id_index as usize].key,

solana-programs/programs/tuktuk/src/lib.rs

@@ -26,7 +26,7 @@ pub mod tuktuk {
         initialize_task_queue_v0::handler(ctx, args)
     }
 
-    pub fn queue_task_v0(ctx: Context<QueuetaskV0>, args: QueueTaskArgsV0) -> Result<()> {
+    pub fn queue_task_v0(ctx: Context<QueueTaskV0>, args: QueueTaskArgsV0) -> Result<()> {
         queue_task_v0::handler(ctx, args)
     }
 

solana-programs/programs/tuktuk/src/state.rs

@@ -89,6 +89,9 @@ pub struct TaskV0 {
     pub transaction: CompiledTransactionV0,
     pub queued_at: i64,
     pub bump_seed: u8,
+    // Number of free tasks to append to the end of the accounts. This allows
+    // you to easily add new tasks
+    pub free_tasks: u8,
 }
 
 #[derive(AnchorSerialize, AnchorDeserialize, Clone, Default)]