Solana Development

Build Solana programs using Anchor framework or native Rust. Both approaches share the same core concepts (accounts, PDAs, CPIs, tokens) but differ in syntax and abstraction level.

Quick Start

Recommended: Anchor Framework

Anchor provides macros and tooling that reduce boilerplate and increase developer productivity:

use anchor_lang::prelude::*;

declare_id!("YourProgramID");

#[program]
pub mod my_program {
    use super::*;

    pub fn initialize(ctx: Context<Initialize>, data: u64) -> Result<()> {
        ctx.accounts.account.data = data;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = user, space = 8 + 8)]
    pub account: Account<'info, MyAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[account]
pub struct MyAccount {
    pub data: u64,
}

When to use Anchor:

• Building DeFi, NFT, or standard programs
• Need TypeScript client generation with IDL
• Want faster development with less boilerplate
• Following common Solana patterns
• New to Solana development

Installation:

cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
avm install latest
avm use latest
anchor --version

Create project:

anchor init my_project
cd my_project
anchor build
anchor test

→ See references/anchor.md for complete Anchor guide

Advanced: Native Rust

Native Rust provides maximum control, optimization potential, and deeper understanding of Solana's runtime:

use solana_program::{
    account_info::AccountInfo,
    entrypoint,
    entrypoint::ProgramResult,
    pubkey::Pubkey,
    msg,
};

entrypoint!(process_instruction);

pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    msg!("Processing instruction");
    // Manual account parsing and validation
    // Manual instruction routing
    Ok(())
}

When to use Native Rust:

• Need maximum compute efficiency (CU optimization critical)
• Require advanced features (versioned transactions, durable nonces, ALTs)
• Learning Solana fundamentals from first principles
• Building highly optimized or specialized programs
• Framework overhead is unacceptable

Setup:

cargo new my_program --lib
cd my_program
# Configure Cargo.toml (see native-rust.md)
cargo build-sbf

→ See references/native-rust.md for complete native Rust guide

Core Concepts

Essential knowledge for all Solana developers, regardless of framework:

Foundational Concepts

• accounts.md - Account model, ownership, rent, validation patterns
• pda.md - Program Derived Addresses: derivation, canonical bumps, signing patterns
• cpi.md - Cross-Program Invocations: calling other programs safely

Program Integration

• tokens-overview.md - Token account structures and ATAs
• tokens-operations.md - Create, mint, transfer, burn, close operations
• tokens-validation.md - Account validation patterns
• tokens-2022.md - Token Extensions Program features
• tokens-patterns.md - Common patterns and security
• testing-overview.md - Test pyramid and strategy
• testing-frameworks.md - Mollusk, Anchor test, Native Rust
• testing-practices.md - Best practices and patterns
• surfpool.md - Local development with Surfpool: mainnet forking, cheatcodes, IaC
• deployment.md - Deploy, upgrade, verify, and manage programs
• production-deployment.md - Verified builds for production (Anchor 0.32.1 workflow)

Client-Side Development

• client-development.md - dApp client: wallet connections, React hooks, SOL/SPL transfers, transaction management. Covers framework-kit (recommended for dApps) and @solana/kit 6.x (server-side/scripts)

Implementation Details

• serialization.md - Account data layout, Borsh, zero-copy patterns
• error-handling.md - Custom error types, propagation, client-side handling
• security.md - Security best practices and defensive programming patterns

Advanced Features

• compute-optimization.md - CU optimization techniques and benchmarking
• versioned-transactions.md - Address Lookup Tables for 256+ accounts
• durable-nonces.md - Offline signing with durable transaction nonces
• transaction-lifecycle.md - Submission, retry patterns, confirmations

Low-Level Details

• sysvars.md - System variables (Clock, Rent, EpochSchedule, SlotHashes)
• builtin-programs.md - System Program and Compute Budget Program

Resources

• resources.md - Official docs, tools, learning paths, community

Common Tasks Quick Reference

Create a new program:

• Anchor: anchor init my_project → anchor.md#getting-started
• Native: cargo new my_program --lib → native-rust.md#setup

Initialize a PDA account:

• Anchor: Use #[account(init, seeds = [...], bump)] → pda.md#anchor
• Native: Manual invoke_signed with System Program → pda.md#native

Transfer SPL tokens:

• Anchor: Use anchor_spl::token::transfer → tokens-operations.md#transferring-tokens
• Native: CPI to Token Program → tokens-operations.md#transferring-tokens

Test your program:

• Both: Mollusk for fast unit tests → testing-frameworks.md#mollusk-testing
• Anchor: anchor test for integration tests → testing-frameworks.md#anchor-specific-testing

Local development with mainnet forking:

• Both: surfpool start for mainnet-forked local network → surfpool.md

Test with mainnet state (Jupiter, Raydium CPIs):

• Both: Use Surfpool JIT forking → surfpool.md#mainnet-forking

Profile compute units in detail:

• Both: surfnet_profileTransaction cheatcode → surfpool.md#transaction-profiling

Deploy to devnet:

• Anchor: anchor deploy → deployment.md#anchor
• Native: solana program deploy → deployment.md#native

Deploy to production (verified builds):

• Both: solana-verify build + solana program deploy → production-deployment.md

Optimize compute units:

• Both: Profile with Mollusk bencher → compute-optimization.md

Handle 40+ accounts:

• Both: Use Address Lookup Tables → versioned-transactions.md

Offline transaction signing:

• Both: Use durable nonces → durable-nonces.md

Decision Guide