Feat: Created the Pinocchio version of Program derived address program

Cargo.toml

@@ -10,6 +10,7 @@ members = [
     "basics/counter/native/program",
     "basics/counter/anchor/programs/counter_anchor",
     "basics/counter/mpl-stack",
+    "basics/counter/pinocchio/program",
     "basics/create-account/native/program",
     "basics/create-account/anchor/programs/create-system-account",
     "basics/cross-program-invocation/anchor/programs/*",
@@ -22,6 +23,7 @@ members = [
     "basics/processing-instructions/anchor/programs/*",
     "basics/program-derived-addresses/native/program",
     "basics/program-derived-addresses/anchor/programs/*",
+    "basics/program-derived-addresses/pinocchio/program",
     "basics/realloc/native/program",
     "basics/realloc/anchor/programs/*",
     "basics/rent/native/program",
@@ -31,11 +33,12 @@ members = [
     "basics/repository-layout/anchor/programs/*",
     "basics/transfer-sol/native/program",
     "basics/transfer-sol/anchor/programs/*",
+    "basics/transfer-sol/pinocchio/program",
     "tokens/token-2022/mint-close-authority/native/program",
     "tokens/token-2022/non-transferable/native/program",
     "tokens/token-2022/default-account-state/native/program",
     "tokens/token-2022/transfer-fee/native/program",
-    "tokens/token-2022/multiple-extensions/native/program",
+    "tokens/token-2022/multiple-extensions/native/program", "basics/counter/pinocchio", "basics/counter/pinocchio/pinocchio-counter",
 ]
 resolver = "2"
 

basics/counter/pinocchio/package.json

@@ -0,0 +1,22 @@
+{
+  "scripts": {
+    "test": "pnpm ts-mocha -p ./tsconfig.json -t 1000000 ./test/counter.test.ts",
+    "build-and-test": "cargo build-sbf --manifest-path=./program/Cargo.toml --sbf-out-dir=./tests/fixtures && pnpm test",
+    "build": "cargo build-sbf --manifest-path=./program/Cargo.toml --sbf-out-dir=./program/target/so",
+    "deploy": "solana program deploy ./program/target/so/hello_solana_program_pinocchio.so"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.47.3"
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.1.0",
+    "@types/chai": "^4.3.1",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^22.15.2",
+    "chai": "^4.3.4",
+    "mocha": "^9.0.3",
+    "solana-bankrun": "^0.3.0",
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.3.5"
+  }
+}

basics/counter/pinocchio/program/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "pinocchio-counter"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+pinocchio = "0.9.2"
+pinocchio-log = "0.5.1"
+pinocchio-pubkey = "0.3.0"
+bytemuck = {version = "1.23.2", features = ["derive"]}
+pinocchio-system = "0.3.0"

basics/counter/pinocchio/program/src/helpers.rs

@@ -0,0 +1,19 @@
+use bytemuck::{Pod, Zeroable};
+use pinocchio::{account_info::AccountInfo, msg, program_error::ProgramError};
+
+pub fn load<T>(account: &AccountInfo) -> Result<&mut T, ProgramError>
+where
+    T: Pod + Zeroable,
+{
+    let data = unsafe { account.borrow_mut_data_unchecked() };
+
+    bytemuck::try_from_bytes_mut::<T>(data).map_err(|_| ProgramError::InvalidAccountData)
+}
+
+pub fn require(condition: bool, err: ProgramError, msg: &'static str) -> Result<(), ProgramError> {
+    if !condition {
+        msg!(msg);
+        return Err(err);
+    }
+    Ok(())
+}

basics/counter/pinocchio/program/src/instructions/create_counter.rs

@@ -0,0 +1,68 @@
+use crate::{load, require, states::Counter};
+use {
+    pinocchio::{
+        account_info::AccountInfo,
+        instruction::{Seed, Signer},
+        program_error::ProgramError,
+        pubkey::{find_program_address, pubkey_eq, Pubkey},
+        sysvars::{rent::Rent, Sysvar},
+        ProgramResult,
+    },
+    pinocchio_log::log,
+    pinocchio_system::instructions::CreateAccount,
+};
+pub fn process_create_counter(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    log!("Counter Instruction: CreateCounter");
+    validate(program_id, accounts)?;
+
+    if let [creator, counter_pda, _system_program] = accounts {
+        let counter_seeds = &[Counter::PREFIX];
+
+        let (expected_counter, bump) = find_program_address(counter_seeds, program_id);
+
+        require(
+            pubkey_eq(&expected_counter, counter_pda.key()),
+            ProgramError::IncorrectProgramId,
+            "Validation Error: Seed constraints violated",
+        )?;
+        let curve_bump: &[u8] = &[bump];
+        let seeds = [Seed::from(Counter::PREFIX), Seed::from(curve_bump)];
+        let signer = Signer::from(&seeds);
+
+        CreateAccount {
+            from: creator,
+            lamports: Rent::get()?.minimum_balance(Counter::SIZE),
+            owner: program_id,
+            space: Counter::SIZE as u64,
+            to: counter_pda,
+        }
+        .invoke_signed(&[signer])?;
+
+        let counter = load::<Counter>(counter_pda)?;
+
+        counter.count = 0;
+
+        Ok(())
+    } else {
+        Err(ProgramError::NotEnoughAccountKeys)
+    }
+}
+pub fn validate(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    if let [creator, counter_pda, _system_program] = accounts {
+        require(
+            creator.is_signer(),
+            ProgramError::MissingRequiredSignature,
+            "Validation Error: Creator must be a signer",
+        )?;
+
+        require(
+            counter_pda.is_writable(),
+            ProgramError::InvalidAccountData,
+            "Validation Error: Counter program Writable priviledge escalated",
+        )?;
+
+        Ok(())
+    } else {
+        Err(ProgramError::NotEnoughAccountKeys)
+    }
+}

basics/counter/pinocchio/program/src/instructions/increment_counter.rs

@@ -0,0 +1,60 @@
+use crate::{load, require, states::Counter};
+use {
+    pinocchio::{
+        account_info::AccountInfo,
+        program_error::ProgramError,
+        pubkey::{find_program_address, pubkey_eq, Pubkey},
+        ProgramResult,
+    },
+    pinocchio_log::log,
+};
+
+pub fn process_increment_counter(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    log!("Counter Instruction: IncrementCounter");
+    validate(program_id, accounts)?;
+
+    if let [_user, counter_pda] = accounts {
+        let counter = load::<Counter>(counter_pda)?;
+
+        counter.count += 1;
+        Ok(())
+    } else {
+        Err(ProgramError::NotEnoughAccountKeys)
+    }
+}
+
+pub fn validate(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    if let [user, counter_pda] = accounts {
+        require(
+            user.is_signer(),
+            ProgramError::MissingRequiredSignature,
+            "Validation Error: User must be a signer",
+        )?;
+
+        let counter_seeds = &[Counter::PREFIX];
+
+        let (expected_counter, _) = find_program_address(counter_seeds, program_id);
+
+        require(
+            pubkey_eq(&expected_counter, counter_pda.key()),
+            ProgramError::IncorrectProgramId,
+            "Validation Error: Seed constraints violated",
+        )?;
+
+        require(
+            counter_pda.data_len() == Counter::SIZE,
+            ProgramError::UninitializedAccount,
+            "Validation Error: Counter isn't initialized yet",
+        )?;
+
+        require(
+            counter_pda.is_writable(),
+            ProgramError::InvalidAccountData,
+            "Validation Error: Counter program Writable priviledge escalated",
+        )?;
+
+        Ok(())
+    } else {
+        Err(ProgramError::NotEnoughAccountKeys)
+    }
+}

basics/counter/pinocchio/program/src/instructions/mod.rs

@@ -0,0 +1,20 @@
+use pinocchio::program_error::ProgramError;
+pub mod create_counter;
+pub mod increment_counter;
+#[repr(u8)]
+pub enum CounterInstructions {
+    CreateCounter,
+    Increment,
+}
+
+impl TryFrom<&u8> for CounterInstructions {
+    type Error = ProgramError;
+
+    fn try_from(value: &u8) -> Result<Self, Self::Error> {
+        match *value {
+            0 => Ok(CounterInstructions::CreateCounter),
+            1 => Ok(CounterInstructions::Increment),
+            _ => Err(ProgramError::InvalidInstructionData),
+        }
+    }
+}

basics/counter/pinocchio/program/src/lib.rs

@@ -0,0 +1,16 @@
+#![no_std]
+use pinocchio::{no_allocator, nostd_panic_handler, program_entrypoint};
+use pinocchio_pubkey::declare_id;
+
+pub mod helpers;
+pub mod instructions;
+pub mod processor;
+pub mod states;
+pub use helpers::*;
+use processor::*;
+
+program_entrypoint!(process_instructions);
+nostd_panic_handler!();
+no_allocator!();
+
+declare_id!("8TpdLD58VBWsdzxRi2yRcmKJD9UcE2GuUrBwsyCwpbUN");

basics/counter/pinocchio/program/src/processor.rs

@@ -0,0 +1,23 @@
+use crate::instructions::{
+    create_counter::process_create_counter, increment_counter::process_increment_counter,
+    CounterInstructions,
+};
+use pinocchio::{
+    account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+};
+
+pub fn process_instructions(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    ix_data: &[u8],
+) -> ProgramResult {
+    let (disc, _) = ix_data
+        .split_first()
+        .ok_or(ProgramError::InvalidInstructionData)?;
+
+    match CounterInstructions::try_from(disc)? {
+        CounterInstructions::CreateCounter => process_create_counter(program_id, accounts)?,
+        CounterInstructions::Increment => process_increment_counter(program_id, accounts)?,
+    }
+    Ok(())
+}

basics/counter/pinocchio/program/src/states/counter.rs

@@ -0,0 +1,12 @@
+use bytemuck::{Pod, Zeroable};
+
+#[repr(C)]
+#[derive(Clone, Copy, Zeroable, Pod)]
+pub struct Counter {
+    pub count: u64,
+}
+
+impl Counter {
+    pub const PREFIX: &[u8] = b"counter";
+    pub const SIZE: usize = core::mem::size_of::<Self>();
+}

basics/counter/pinocchio/program/src/states/mod.rs

@@ -0,0 +1,2 @@
+pub mod counter;
+pub use counter::*;