Add Token2022 Extensions

Cargo.toml

@@ -10,6 +10,8 @@ members = [
     "sdk/log/macro",
     "sdk/pinocchio",
     "sdk/pubkey",
+    "cpi-tests/programs/*",
+    "cpi-tests/tests",
 ]
 
 [workspace.package]
@@ -23,6 +25,9 @@ five8_const = "0.1.4"
 pinocchio = { version = "0.9", path = "sdk/pinocchio" }
 pinocchio-log-macro = { version = "0.5", path = "sdk/log/macro" }
 pinocchio-pubkey = { version = "0.3", path = "sdk/pubkey" }
+pinocchio-token = { version = "0.4.0", path = "./programs/token" }
+pinocchio-token-2022 = { version = "0.1.0", path = "./programs/token-2022" }
+token-2022-proxy = { version = "1.0.0", path = "./cpi-tests/programs/token-2022-proxy" }
 quote = "1.0"
 regex = "1"
 syn = "1.0"

cpi-tests/README.md

@@ -0,0 +1,215 @@
+# Pinocchio Interface Test Setup for SPL Token-2022
+
+A comprehensive testing framework for validating the Pinocchio interface implementation against the SPL Token-2022 program, enabling developers to contribute confidently to the Pinocchio interface repository.
+
+## Problem Statement
+
+Before this test setup, the Pinocchio interface lacked comprehensive testing coverage, which meant:
+
+- **Late Error Discovery**: Interface implementation errors were only discovered when used in downstream projects
+- **No Validation Framework**: Contributors had no way to verify their interface implementations worked correctly
+- **Manual Testing Burden**: Developers had to manually construct instructions and test scenarios
+- **Inconsistent Testing**: No standardized approach for testing Cross-Program Invocations (CPI) and state reading functionality
+
+This test setup solves these problems by providing a complete, automated testing environment that validates both the interface implementation and its real-world usage patterns.
+
+## Architecture Overview
+
+![Architecture Diagram](./diagrams/pinocchio_cpi_test_setup_architecture.drawio.svg)
+
+The test setup consists of four main components:
+
+### 1. Token-2022 Program
+- **Purpose**: The actual SPL Token-2022 program implementation using Pinocchio interface
+- **Key Features**: 
+  - Implements token operations via Pinocchio interface
+  - Handles state validation and initialization checks
+  - Serves as the target program for CPI calls
+
+### 2. Token-2022-Proxy Program
+- **Purpose**: Demonstrates real-world usage of Pinocchio interface for CPI calls
+- **Function**: Acts as an intermediary that executes Token-2022 operations through CPI
+- **Why Important**: Simulates how other programs would integrate with Pinocchio interface in production
+
+### 3. Target-Based Execution System
+- **Purpose**: Unified system for switching between SPL and Proxy program execution
+- **Benefits**:
+  - Single interface for testing both execution paths
+  - Eliminates code duplication
+  - Provides consistent testing patterns
+
+### 4. Test Functions
+- **Design**: Functions that handle both SPL and Proxy execution based on `Target` parameter
+- **Purpose**: Execute Token-2022 operations and query state through either interface
+- **Advantages**:
+  - Simplified test creation without manual instruction building
+  - Easy state reading using both SPL and Pinocchio interfaces
+  - Consistent behavior across different instructions
+
+## Code Structure
+
+### Target Enum
+
+The `Target` enum controls which execution path and interface to use:
+
+```rust
+/// Switch between SPL and Proxy programs
+pub enum Target {
+    /// Execute token-2022 instruction directly, read state using SPL interface
+    Spl,
+    /// Execute token-2022 instruction using proxy program, read state using Pinocchio interface
+    Proxy,
+}
+```
+
+### Trait Organization
+Each Token-2022 instruction has its own trait with unified handlers:
+
+```rust
+pub trait Token2022InitializeMintExtension {
+    // Account management
+    fn token_2022_try_create_mint_account(
+        &mut self,
+        sender: AppUser,
+        mint: Option<Keypair>,
+        extensions: Option<&[ExtensionType]>,
+    ) -> TestResult<(TransactionMetadata, Keypair)>;
+
+    // Unified execution (Target determines SPL vs Proxy)
+    fn token_2022_try_initialize_mint(
+        &mut self,
+        target: Target,
+        sender: AppUser,
+        mint: &Pubkey,
+        decimals: u8,
+        mint_authority: &Pubkey,
+        freeze_authority: Option<&Pubkey>,
+    ) -> TestResult<TransactionMetadata>;
+
+    // Unified state reading (Target determines interface)
+    fn token_2022_query_mint(&self, target: Target, mint: &Pubkey) -> TestResult<Mint>;
+}
+```
+
+### Test Categories
+
+**1. Direct SPL Tests**
+```rust
+#[test]
+fn initialize_mint() -> TestResult<()> {
+    // Tests direct Token-2022 program execution
+    app.token_2022_try_initialize_mint(Target::Spl, ...)?;
+    assert_eq!(app.token_2022_query_mint(Target::Spl, mint)?, expected_state);
+}
+```
+
+**2. Proxy/CPI Tests**
+```rust
+#[test] 
+fn proxy_initialize_mint() -> TestResult<()> {
+    // Tests Pinocchio interface through proxy program
+    app.token_2022_try_initialize_mint(Target::Proxy, ...)?;
+    assert_eq!(app.token_2022_query_mint(Target::Proxy, mint)?, expected_state);
+}
+```
+
+## Getting Started
+
+### Prerequisites
+- Rust toolchain with Solana program development setup
+- LiteSVM testing environment
+
+### Building and Testing
+
+```bash
+# Build and test with detailed output
+./test.sh s
+
+# Build and test (standard output)  
+./test.sh
+```
+
+### Adding New Instruction Tests
+
+1. **Create a new trait** for your instruction:
+```rust
+pub trait Token2022YourInstructionExtension {
+    fn token_2022_try_your_instruction(
+        &mut self,
+        target: Target,
+        // ... other parameters
+    ) -> TestResult<TransactionMetadata>;
+
+    fn token_2022_query_your_state(
+        &self,
+        target: Target, 
+        account: &Pubkey,
+    ) -> TestResult<YourState>;
+}
+```
+
+2. **Implement the trait** following the established patterns:
+   - Use `Target` to determine execution path and state reading interface
+   - Handle both SPL direct execution and proxy CPI calls
+   - Implement state query methods for both interfaces
+
+3. **Create test file** with both direct and proxy tests:
+   - Test the instruction execution with both targets
+   - Verify state changes
+   - Test error conditions
+   - Validate CPI behavior
+
+## Testing Strategy
+
+### What Gets Tested
+
+**Interface Correctness**
+- CPI calls work as expected
+- State reading returns correct data
+- Error handling behaves properly
+
+**Implementation Validation**
+- Pinocchio interface matches SPL interface behavior
+- State structures are correctly mapped
+- Account validation logic is consistent
+
+**Integration Testing**
+- Proxy programs can successfully call Token-2022 via Pinocchio
+- Cross-program invocations maintain state consistency
+- Complex instruction sequences work correctly
+
+### Test Patterns
+
+1. **Setup Phase**: Create necessary accounts and initial state
+2. **Execution Phase**: Test both `Target::Spl` and `Target::Proxy` execution
+3. **Validation Phase**: Compare state using both SPL and Pinocchio interfaces
+4. **Edge Cases**: Test error conditions and boundary cases
+
+## Contributing
+
+When contributing to the Pinocchio interface:
+
+1. **Add Tests First**: Create comprehensive tests for any new interface implementations
+2. **Follow Patterns**: Use the established trait and testing patterns with `Target` enum
+3. **Test Both Paths**: Always test both direct SPL and proxy execution
+4. **Validate State**: Ensure state reading works correctly through Pinocchio interface
+5. **Document Edge Cases**: Add tests for error conditions and special cases
+
+## Benefits for Contributors
+
+- **Confidence**: Know your interface implementation works before integration
+- **Fast Feedback**: Catch errors immediately during development
+- **Standardized Testing**: Consistent patterns across all instructions
+- **Real-world Validation**: Test actual CPI usage scenarios
+- **Easy Debugging**: Clear test structure makes issues easy to identify and fix
+
+## Future Extensions
+
+This framework can be extended to test:
+- Additional SPL Token-2022 instructions
+- Token-2022 extensions
+- Complex multi-instruction scenarios
+- Performance characteristics
+- Error recovery patterns
+
+By using this test setup, contributors can ensure their Pinocchio interface implementations are robust, correct, and ready for production use.

cpi-tests/programs/token-2022-proxy/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "token-2022-proxy"
+version = "1.0.0"
+description = "A program to test Token-2022 Pinocchio CPI"
+repository = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = []
+std = []
+
+[dependencies]
+pinocchio = { workspace = true }
+pinocchio-log-macro = { workspace = true }
+pinocchio-pubkey = { workspace = true }
+pinocchio-token-2022 = { workspace = true }
+spl-token-group-interface = "0.7.1"
+spl-token-2022-interface = "2.0.0"
+solana-program-option = "3.0.0"
+solana-address = "1.0.0"
+spl-pod = "0.7.1"

cpi-tests/programs/token-2022-proxy/src/helpers.rs

@@ -0,0 +1,23 @@
+use {
+    pinocchio::{log::sol_log, program_error::ProgramError, pubkey::Pubkey},
+    solana_program_option::COption,
+    spl_pod::optional_keys::OptionalNonZeroPubkey,
+};
+
+pub type Result<T> = core::result::Result<T, ProgramError>;
+
+pub fn from_c_option<T>(data: COption<T>) -> Option<T> {
+    if data.is_some() {
+        Some(data.unwrap())
+    } else {
+        None
+    }
+}
+
+pub fn from_optional_non_zero_pubkey(address: OptionalNonZeroPubkey) -> Option<Pubkey> {
+    Option::<solana_address::Address>::from(address).map(|x| x.to_bytes())
+}
+
+pub fn show<T: core::fmt::Debug>(label: &str, data: T) {
+    sol_log(&format!("✅ {}: {:?}", label, data));
+}

cpi-tests/programs/token-2022-proxy/src/instructions/cpi_guard/disable_guard.rs

@@ -0,0 +1,25 @@
+use {
+    pinocchio::{account_info::AccountInfo, program_error::ProgramError, ProgramResult},
+    pinocchio_token_2022::extension::cpi_guard,
+};
+
+pub fn disable_guard(accounts: &[AccountInfo], _instruction_data: &[u8]) -> ProgramResult {
+    // The accounts should be: [account, owner, ...signers, token_program]
+
+    if accounts.len() < 4 {
+        Err(ProgramError::NotEnoughAccountKeys)?
+    }
+
+    let token_program = accounts.last().unwrap(); // token_program is always last
+    let account = &accounts[0];
+    let owner = &accounts[1];
+    let signers = &accounts[2..accounts.len() - 1]; // everything between owner and token_program
+
+    cpi_guard::DisableCpiGuard {
+        token_account: account,
+        owner,
+        signers,
+        token_program: &token_program.key(),
+    }
+    .invoke()
+}

cpi-tests/programs/token-2022-proxy/src/instructions/cpi_guard/enable_guard.rs

@@ -0,0 +1,34 @@
+use {
+    pinocchio::{account_info::AccountInfo, program_error::ProgramError, ProgramResult},
+    pinocchio_token_2022::extension::cpi_guard,
+};
+
+pub fn enable_guard(accounts: &[AccountInfo], _instruction_data: &[u8]) -> ProgramResult {
+    // The accounts should be: [account, owner, ...signers, token_program]
+
+    if accounts.len() < 4 {
+        Err(ProgramError::NotEnoughAccountKeys)?
+    }
+
+    let token_program = accounts.last().unwrap(); // token_program is always last
+    let account = &accounts[0];
+    let owner = &accounts[1];
+    let signers = &accounts[2..accounts.len() - 1]; // everything between owner and token_program
+
+    {
+        let acc = account.try_borrow_data()?;
+        let state = pinocchio_token_2022::extension::cpi_guard::state::CpiGuard::from_bytes(&acc)?;
+
+        if state.lock_cpi() {
+            return Ok(());
+        }
+    }
+
+    cpi_guard::EnableCpiGuard {
+        token_account: account,
+        owner,
+        signers,
+        token_program: &token_program.key(),
+    }
+    .invoke()
+}

cpi-tests/programs/token-2022-proxy/src/instructions/cpi_guard/mod.rs

@@ -0,0 +1,5 @@
+mod enable_guard;
+mod disable_guard;
+
+pub use enable_guard::*;
+pub use disable_guard::*;

cpi-tests/programs/token-2022-proxy/src/instructions/default_account_state/initialize.rs

@@ -0,0 +1,31 @@
+use {
+    pinocchio::{account_info::AccountInfo, program_error::ProgramError, ProgramResult},
+    pinocchio_token_2022::extension::default_account_state::instructions::initialize::InitializeDefaultAccountState,
+    spl_token_2022_interface::extension::default_account_state::instruction::decode_instruction,
+};
+
+pub fn initialize(accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult {
+    let [mint, token_program] = accounts else {
+        Err(ProgramError::InvalidAccountData)?
+    };
+
+    let (_, state) = decode_instruction(instruction_data)
+        .map_err(|_| ProgramError::InvalidInstructionData)?;
+
+    if pinocchio_token_2022::state::Mint::from_account_info(mint)?.is_initialized() {
+        let config = pinocchio_token_2022::extension::default_account_state::state::DefaultAccountStateConfig::from_account_info(mint)?;
+
+        if config.state() != state as u8 {
+            Err(ProgramError::InvalidAccountData)?
+        }
+
+        return Ok(());
+    }
+
+    InitializeDefaultAccountState {
+        mint_account: mint,
+        state: state as u8,
+        token_program: &token_program.key(),
+    }
+    .invoke()
+}

cpi-tests/programs/token-2022-proxy/src/instructions/default_account_state/mod.rs

@@ -0,0 +1,5 @@
+pub mod initialize;
+pub mod update;
+
+pub use initialize::*;
+pub use update::*;