Small edits to counter example (#83)

* Small edits to counter example

* fix tests (#84)

---------

Co-authored-by: mwrites <[email protected]>

Author: nickgarfield

1-counter/programs/counter/src/id.rs

@@ -1,94 +1,90 @@
-pub mod id;
-
-pub use id::ID;
 use anchor_lang::prelude::*;
 use anchor_lang::solana_program::{
     instruction::Instruction, native_token::LAMPORTS_PER_SOL, system_program,
 };
 use anchor_lang::InstructionData;
-use clockwork_sdk::state::{ThreadAccount};
+use clockwork_sdk::state::{Thread, ThreadAccount};
 
+declare_id!("HsjAAC3PvCVujGdUwoaLpjbPPGbFgimpFZBHrSooGX2V");
 
 #[program]
 pub mod counter {
     use super::*;
 
-    // Just here to delete the `Counter` account and reset the tests to a clean state
-    pub fn delete(_ctx: Context<Delete>) -> Result<()> {
-        Ok(())
-    }
-
     pub fn increment(ctx: Context<Increment>) -> Result<()> {
         let counter = &mut ctx.accounts.counter;
-
         counter.current_value = counter.current_value.checked_add(1).unwrap();
         counter.updated_at = Clock::get().unwrap().unix_timestamp;
-        msg!("Counter value: {}, updated_at: {}", counter.current_value, counter.updated_at);
+        msg!(
+            "Counter value: {}, updated_at: {}",
+            counter.current_value,
+            counter.updated_at
+        );
         Ok(())
     }
 
     pub fn initialize(ctx: Context<Initialize>, thread_id: Vec<u8>) -> Result<()> {
-        // Get accounts
+        // Get accounts.
         let system_program = &ctx.accounts.system_program;
         let clockwork_program = &ctx.accounts.clockwork_program;
         let payer = &ctx.accounts.payer;
         let thread = &ctx.accounts.thread;
-        let thread_authority_pda = &ctx.accounts.thread_authority_pda;
-        let bump = *ctx.bumps.get("thread_authority_pda").unwrap();
+        let thread_authority = &ctx.accounts.thread_authority;
         let counter = &mut ctx.accounts.counter;
 
-        // 1️⃣ Prepare an instruction to feed to the Thread
+        // 1️⃣ Prepare an instruction to be automated.
         let target_ix = Instruction {
             program_id: ID,
             accounts: crate::accounts::Increment {
-                system_program: system_program.key(),
                 counter: counter.key(),
                 thread: thread.key(),
-                thread_authority_pda: thread_authority_pda.key(),
-            }.to_account_metas(Some(true)),
+                thread_authority: thread_authority.key(),
+            }
+            .to_account_metas(Some(true)),
             data: crate::instruction::Increment {}.data(),
         };
 
-        // 2️⃣ Define a trigger for the Thread to execute
+        // 2️⃣ Define a trigger for the thread (every 10 secs).
         let trigger = clockwork_sdk::state::Trigger::Cron {
             schedule: "*/10 * * * * * *".into(),
             skippable: true,
         };
 
-        // 3️⃣ Create Thread via CPI
+        // 3️⃣ Create thread via CPI.
+        let bump = *ctx.bumps.get("thread_authority").unwrap();
         clockwork_sdk::cpi::thread_create(
             CpiContext::new_with_signer(
                 clockwork_program.to_account_info(),
                 clockwork_sdk::cpi::ThreadCreate {
                     payer: payer.to_account_info(),
                     system_program: system_program.to_account_info(),
                     thread: thread.to_account_info(),
-                    authority: thread_authority_pda.to_account_info(),
+                    authority: thread_authority.to_account_info(),
                 },
                 &[&[THREAD_AUTHORITY_SEED, &[bump]]],
             ),
-            LAMPORTS_PER_SOL,   // amount
+            LAMPORTS_PER_SOL,       // amount
             thread_id,              // id
-            vec![target_ix.into()], // Instructions vec
-            trigger,                // Trigger
+            vec![target_ix.into()], // instructions
+            trigger,                // trigger
         )?;
 
         Ok(())
     }
 
-    pub fn delete_thread(ctx: Context<DeleteThread>) -> Result<()> {
+    pub fn reset(ctx: Context<Reset>) -> Result<()> {
         // Get accounts
         let clockwork_program = &ctx.accounts.clockwork_program;
         let payer = &ctx.accounts.payer;
         let thread = &ctx.accounts.thread;
-        let thread_authority_pda = &ctx.accounts.thread_authority_pda;
-        let bump = *ctx.bumps.get("thread_authority_pda").unwrap();
+        let thread_authority = &ctx.accounts.thread_authority;
 
-        // The actual CPI
+        // Delete thread via CPI.
+        let bump = *ctx.bumps.get("thread_authority").unwrap();
         clockwork_sdk::cpi::thread_delete(CpiContext::new_with_signer(
             clockwork_program.to_account_info(),
             clockwork_sdk::cpi::ThreadDelete {
-                authority: thread_authority_pda.to_account_info(),
+                authority: thread_authority.to_account_info(),
                 close_to: payer.to_account_info(),
                 thread: thread.to_account_info(),
             },
@@ -98,139 +94,96 @@ pub mod counter {
     }
 }
 
-/*
-**  Accounts
- */
+/// The Counter account tracks a value and the timestamp of its last update.
 #[account]
 #[derive(Debug)]
 pub struct Counter {
     pub current_value: u64,
     pub updated_at: i64,
 }
 
-/*
-**  Validation Structs
- */
-
-/// Seed for `Counter` account Program Derived Address
-/// ⚠️ Make sure it matches whatever you are using on the client-side
+/// Seed for deriving the `Counter` account PDA.
 pub const SEED_COUNTER: &[u8] = b"counter";
 
-/// Seed for thread_authority pda
-/// ⚠️ Make sure it matches whatever you are using on the client-side
+/// Seed for thread_authority PDA.
 pub const THREAD_AUTHORITY_SEED: &[u8] = b"authority";
 
 #[derive(Accounts)]
 pub struct Increment<'info> {
-    /// The system program.
-    #[account(address = system_program::ID)]
-    pub system_program: Program<'info, System>,
-
     /// The counter account.
-    #[account(
-    mut,
-    seeds = [SEED_COUNTER],
-    bump,
-    )]
+    #[account(mut, seeds = [SEED_COUNTER], bump)]
     pub counter: Account<'info, Counter>,
 
     /// Verify that only this thread can execute the Increment Instruction
-    #[account(
-    signer,
-    constraint = thread.authority.eq(& thread_authority_pda.key())
-    )]
-    pub thread: Account<'info, clockwork_sdk::state::Thread>,
+    #[account(signer, constraint = thread.authority.eq(&thread_authority.key()))]
+    pub thread: Account<'info, Thread>,
 
     /// The Thread Admin
     /// The authority that was used as a seed to derive the thread address
-    /// `thread_authority_pda` should equal `thread.thread_authority`
-    #[account(
-    seeds = [THREAD_AUTHORITY_SEED],
-    bump,
-    )]
-    pub thread_authority_pda: SystemAccount<'info>,
+    /// `thread_authority` should equal `thread.thread_authority`
+    #[account(seeds = [THREAD_AUTHORITY_SEED], bump)]
+    pub thread_authority: SystemAccount<'info>,
 }
 
 #[derive(Accounts)]
-pub struct Delete<'info> {
-    #[account(mut)]
-    pub payer: Signer<'info>,
-
+#[instruction(thread_id: Vec<u8>)]
+pub struct Initialize<'info> {
+    /// The counter account to initialize.
     #[account(
-    mut,
-    seeds = [SEED_COUNTER],
-    bump,
-    close = payer
+        init,
+        payer = payer,
+        seeds = [SEED_COUNTER],
+        bump,
+        space = 8 + std::mem::size_of::< Counter > (),
     )]
     pub counter: Account<'info, Counter>,
-}
 
-#[derive(Accounts)]
-#[instruction(thread_id: Vec < u8 >)]
-pub struct Initialize<'info> {
-    /// Who's paying for this Initialize Transaction
-    /// (not to be confused with the thread executions)
+    /// The Clockwork thread program.
+    #[account(address = clockwork_sdk::ID)]
+    pub clockwork_program: Program<'info, clockwork_sdk::ThreadProgram>,
+
+    /// The signer who will pay to initialize the program.
+    /// (not to be confused with the thread executions).
     #[account(mut)]
     pub payer: Signer<'info>,
 
+    /// The Solana system program.
     #[account(address = system_program::ID)]
     pub system_program: Program<'info, System>,
 
-    /// Clockwork Program (Thread Program)
-    #[account(address = clockwork_sdk::ID)]
-    pub clockwork_program: Program<'info, clockwork_sdk::ThreadProgram>,
-
-    /// Address to assign to the newly created Thread
-    #[account(
-    mut,
-    address = clockwork_sdk::state::Thread::pubkey(thread_authority_pda.key(), thread_id)
-    )]
+    /// Address to assign to the newly created thread.
+    #[account(mut, address = Thread::pubkey(thread_authority.key(), thread_id))]
     pub thread: SystemAccount<'info>,
 
-    /// The Thread Admin
-    /// The address that was used as a seed to derive the thread address with
-    /// `clockworkProvider.getThreadPDA(threadAuthority, threadId)`
-    /// `thread_authority_pda` should equal `thread.authority`
-    #[account(
-    seeds = [THREAD_AUTHORITY_SEED],
-    bump,
-    )]
-    pub thread_authority_pda: SystemAccount<'info>,
-
-    #[account(
-    init,
-    payer = payer,
-    seeds = [SEED_COUNTER],
-    bump,
-    space = 8 + std::mem::size_of::< Counter > (),
-    )]
-    pub counter: Account<'info, Counter>,
+    /// The pda that will own and manage the thread.
+    #[account(seeds = [THREAD_AUTHORITY_SEED], bump)]
+    pub thread_authority: SystemAccount<'info>,
 }
 
 #[derive(Accounts)]
-pub struct DeleteThread<'info> {
-    /// Who's paying
+pub struct Reset<'info> {
+    /// The signer.
     #[account(mut)]
     pub payer: Signer<'info>,
 
-    /// Clockwork Program (Thread Program)
+    /// The Clockwork thread program.
     #[account(address = clockwork_sdk::ID)]
     pub clockwork_program: Program<'info, clockwork_sdk::ThreadProgram>,
 
-    /// Address to assign to the newly created Thread
-    #[account(
-    mut,
-    address = thread.pubkey(),
-    constraint = thread.authority.eq(& thread_authority_pda.key())
-    )]
-    pub thread: Account<'info, clockwork_sdk::state::Thread>,
+    /// The thread to reset.
+    #[account(mut, address = thread.pubkey(), constraint = thread.authority.eq(&thread_authority.key()))]
+    pub thread: Account<'info, Thread>,
 
-    /// The Thread Admin
-    /// The address that was used as a seed to derive the thread address
-    /// `thread_authority_pda` should equal `thread.authority`
+    /// The pda that owns and manages the thread.
+    #[account(seeds = [THREAD_AUTHORITY_SEED], bump)]
+    pub thread_authority: SystemAccount<'info>,
+
+    /// Close the counter account
     #[account(
-    seeds = [THREAD_AUTHORITY_SEED],
-    bump,
+        mut,
+        seeds = [SEED_COUNTER],
+        bump,
+        close = payer
     )]
-    pub thread_authority_pda: SystemAccount<'info>,
+    pub counter: Account<'info, Counter>,
 }

1-counter/programs/counter/src/lib.rs

@@ -6,7 +6,7 @@ import { Counter } from "../target/types/counter";
 import { print_address, print_thread, waitForThreadExec } from "../../utils/helpers";
 
 // 0️⃣  Import the Clockwork SDK.
-import { ClockworkProvider, PAYER_PUBKEY } from "@clockwork-xyz/sdk";
+import { ClockworkProvider } from "@clockwork-xyz/sdk";
 
 
 const provider = anchor.AnchorProvider.env();
@@ -55,7 +55,7 @@ describe("counter", () => {
                     systemProgram: SystemProgram.programId,
                     clockworkProgram: clockworkProvider.threadProgram.programId,
                     thread: threadAddress,
-                    threadAuthorityPda: threadAuthority,
+                    threadAuthority: threadAuthority,
                     counter: counter,
                 })
                 .rpc();
@@ -84,22 +84,16 @@ describe("counter", () => {
     // Just some cleanup to reset the test to a clean state
     afterEach(async () => {
         try {
-        await program.methods
-            .deleteThread()
-            .accounts({
-                payer: wallet.publicKey,
-                clockworkProgram: clockworkProvider.threadProgram.programId,
-                thread: threadAddress,
-                threadAuthorityPda: threadAuthority,
-            })
-            .rpc();
-        await program.methods
-            .delete()
-            .accounts({
-                payer: wallet.publicKey,
-                counter: counter,
-            })
-            .rpc();
-        } catch (e) {}
+            await program.methods
+                .reset()
+                .accounts({
+                    payer: wallet.publicKey,
+                    clockworkProgram: clockworkProvider.threadProgram.programId,
+                    counter: counter,
+                    thread: threadAddress,
+                    threadAuthority: threadAuthority,
+                })
+                .rpc();
+        } catch (e) { }
     })
 });

1-counter/tests/counter.ts

@@ -32,7 +32,7 @@ echo "project_name: $crate_name"
 echo "program_id: $program_id"
 
 # Update program IDs
-replace_in_file 's/^declare_id!(".*");/declare_id!("'${program_id}'");/g' "programs/$crate_name/src/id.rs"
+replace_in_file 's/^declare_id!(".*");/declare_id!("'${program_id}'");/g' "programs/$crate_name/src/lib.rs"
 replace_in_file 's/^'${crate_name}' = ".*"/'${crate_name}' = "'${program_id}'"/g' Anchor.toml
 
 # Rebuild with new program ID