React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go

Solana Developer SME Guide

Sections

Solana Foundations & Architecture

Solana Foundations In Depth Solana Basics SOL, Lamports & Units Clusters & Networks RPC Providers Slots, Blocks & Epochs Keypairs & Addresses The Solana Mental Model vs. EVM How a Transaction Flows Types of Wallets Block Explorers Wallets & Explorers Solana Fundamentals Best Practices

The Account Blueprint Account Model Basics Account Anatomy Rent & Rent-Exemption System Accounts vs. Program Accounts Program-Owned State Account Ownership & Permissions Data Accounts & Layout Creating & Closing Accounts Account Model Best Practices

Sealevel Runtime Key Points Programs Basics The SVM & sBPF Sealevel Parallel Execution Account Locks & Conflicts Compute Units & Budgets The Program Entrypoint Stateless Programs Program Loaders & Upgradeability Sealevel Runtime Best Practices

The Transaction Transactions Basics Instructions & Accounts Versioned Transactions (v0)Address Lookup Tables (ALTs)The Compute Budget Program Priority Fees Blockhashes & Expiry Simulating Transactions Jito Tips & Bundles Transactions Best Practices

Solana Architecture In Detail Architecture Overview Proof of History (PoH)Turbine Gulf Stream Sealevel Pipelining (TPU/TVU)Cloudbreak & Accounts DB Gossip & Cluster Communication Leader Schedule & Block Production Architecture Best Practices

Consensus In Depth Consensus Basics TowerBFT + PoH Vote Accounts & Voting Introducing Alpenglow Votor Rotor Migration & Developer Impact Confirmation Levels in Clients Consensus Best Practices

Tokenomics Blueprint Economics Basics Inflation & Staking Rewards Staking & Delegation Liquid Staking & LSTs MEV on Solana Priority Fee Markets Governance & SIMDs Realms & On-Chain Governance Economics Best Practices

CLI, Tooling & Local Dev

The Solana CLI Solana CLI Basics Keypairs with solana-keygen Airdrops & Balances Inspecting Accounts & Programs Sending SOL & Transactions Deploying Programs spl-token CLI Logs & Debugging Solana CLI Best Practices

Toolchain Blueprint Toolchain Overview Version Management (agave-install / avm)create-solana-dapp Mucho CLI Building Programs (cargo build-sbf)Verifiable Builds (solana-verify)Editor & rust-analyzer Setup Toolchain Best Practices

Local Dev In Detail Local Dev Basics solana-test-validator Cloning Mainnet Accounts Surfpool Loading Programs & Fixtures Local Logs & Debugging Localnet vs Devnet Workflow Local Dev Best Practices

RPC & WebSockets In Depth RPC Basics Core RPC Methods getProgramAccounts & Filters WebSocket Subscriptions The DAS API Priority Fee & Simulation APIs RPC Providers Pagination & Efficiency RPC Best Practices

Indexing Blueprint Indexing Basics Geyser Plugins Yellowstone gRPC Webhooks Building an Indexer Parsing Program Data Analytics & Dashboards Indexing Best Practices

Landing Transactions Key Points Why Transactions Fail to Land Estimating Compute Units Setting Priority Fees Address Lookup Tables in Practice Retries & Blockhash Management Jito Bundles Transaction Assembly Optimization Best Practices

On-Chain Rust

Rust for Solana Programs Rust for Solana Basics no_std & the Program Environment Borsh Serialization Zero-Copy with bytemuck Safe Arithmetic Working with Pubkeys & Accounts Program Size & CU Discipline Error Handling On-Chain Rust for Solana Best Practices

Native Programs In Detail Native Program Basics The Entrypoint & Dispatch Manual Account Validation Instruction Data (de)Serialization Creating Accounts via CPI Reading & Writing Account Data Emitting Logs When to Go Native Native Programs Best Practices

The PDA Blueprint PDA Basics Deriving PDAs Canonical Bumps Signing with PDAs PDAs as Authorities PDA Account Creation Seed Design & Collisions PDA Security Pitfalls PDA Best Practices

CPIs Explained CPI Basics invoke vs invoke_signed Passing Accounts to CPIs CPI to the System Program CPI to SPL Token CPI Depth & Limits Reentrancy & Safety Composability Patterns CPI Best Practices

Serialization Key Points Serialization Basics Account Discriminators Borsh Structs Zero-Copy Accounts realloc & Growing Accounts Space Calculation Data Versioning & Migration Serialization Best Practices

Pinocchio In Depth Lightweight Frameworks Overview Pinocchio Basics Building a Program with Pinocchio Steel Framework CU & Binary-Size Wins Interop & Migration When to Use Which Framework Lightweight Frameworks Best Practices

Errors, Logs & Events Error Handling Basics Custom Error Enums Logging with msg!Emitting Events Decoding Errors Off-Chain Debugging Failed Transactions Errors & Logs Best Practices

On-Chain Patterns Blueprint Program Patterns Basics Account Initialization Patterns Vault & Escrow State Machines On-Chain Access Control & Authorities Fee & Treasury Patterns Time & Clock Upgrade-Safe Data Design Program Patterns Best Practices

Anchor Framework

Anchor In Depth Anchor Basics Project Structure The #[program] Module The Accounts Struct Building & Deploying The Anchor Workflow Anchor vs Native Anchor Basics Best Practices

Anchor Constraints Explained Account Types The #[account] Constraints init & init_if_needed Space & Rent Seeds & Bump Constraints Token & Associated Token Constraints Custom Constraints Account Validation Order Accounts & Constraints Best Practices

Instructions & Context Instruction Handlers Instruction Arguments Accessing Accounts The System & Token Programs Return Values & CPIs from Handlers Instruction Ordering & Dependencies Instructions Best Practices

PDAs in Anchor Key Points PDAs in Anchor Signing with PDAs Storing Bumps PDA Authorities Client-Side PDA Derivation Common PDA Mistakes PDAs in Anchor Best Practices

Anchor CPIs In Detail CPI Basics in Anchor SPL Token CPIs Signed CPIs CPI to Custom Programs Passing Remaining Accounts CPI Safety CPIs in Anchor Best Practices

Anchor Errors & Events #[error_code] & require!Custom Error Messages Events with emit!emit_cpi! & Self-CPI Events Logging & CU Cost Client-Side Error Decoding Errors & Events Best Practices

IDL & Codegen Blueprint The Anchor IDL declare_program!Generating TS Clients Codama from an Anchor IDL IDL Versioning On-Chain IDLs Codegen Best Practices

Advanced Anchor Key Points Zero-Copy Accounts realloc in Anchor remaining_accounts Custom Account Types CU & Size Optimization Feature Flags & cfg Interacting with Native/Pinocchio Programs Advanced Anchor Best Practices

Tokens, NFTs & Standards

The SPL Token Program SPL Token Basics Associated Token Accounts (ATAs)Minting & Burning Transfers & Delegates Authorities Decimals & Amounts Wrapped SOL SPL Token in Programs SPL Token Best Practices

Token-2022 In Depth Token-2022 Basics Transfer Fees Transfer Hooks Confidential Transfers Metadata & Metadata Pointer Permanent Delegate & Non-Transferable Interest-Bearing & Default Account State Migrating from SPL Token Token-2022 Best Practices

NFTs & Metaplex Blueprint NFT Basics on Solana Metaplex Core Token Metadata Collections & Verification Candy Machine Royalties & Enforcement Metadata & Storage Reading NFTs (DAS API)NFT Best Practices

Compressed NFTs Explained State Compression Basics How Compression Works Compressed NFTs (Bubblegum)Reading Compressed Assets (DAS)Transferring cNFTs Cost & Trade-offs Compression Best Practices

Frontend & Clients

@solana/kit In Detail @solana/kit Basics RPC & Subscriptions Keypairs & Signers Building Transaction Messages Signing & Sending Codecs & Serialization Address Lookup Tables Migrating from web3.js v1 @solana/kit Best Practices

Wallet Integration Key Points Wallet Basics Wallet Adapter @wallet-ui/react Connecting & Disconnecting Signing Transactions & Messages Autoconnect & Session UX Hardware & Mobile Wallets Wallet Integration Best Practices

Typed Clients Blueprint Typed Clients Basics The Anchor TS Client Codama gill Fetching & Decoding Accounts Building Instructions Keeping Clients in Sync Typed Clients Best Practices

Next.js dApp Integration dApp Integration Basics Providers & App Router Server-Side Reads Client-Side Signing Displaying On-Chain Data Transaction UX API Routes for Transactions Caching & Realtime dApp Integration Best Practices

Solana Pay, Actions & Blinks Solana Pay Basics Transaction Requests Actions (the spec)Blinks Building an Action Security & Verification Solana Pay & Actions Best Practices

Solana Mobile In Depth Solana Mobile Basics Mobile Wallet Adapter (MWA)Building a Mobile dApp Deep Links & Session Handling The dApp Store Seed Vault & Security Solana Mobile Best Practices

DeFi, Security & Testing

DeFi Integrations Blueprint DeFi Basics on Solana Swaps with Jupiter AMMs (Raydium, Orca, Meteora)Perps & Order Books Lending & Borrowing Liquid Staking (LSTs)Jito & MEV Oracles DeFi Integrations Best Practices

Program Security Key Points Security Basics Signer & Owner Checks Account Validation Attacks PDA & Seed Attacks Arithmetic & Overflow Reinitialization Attacks CPI & Reentrancy Risks Sealevel Attacks Catalog Audit Workflow Security Best Practices

Testing Solana Programs Testing Basics LiteSVM Mollusk Bankrun (TS)Anchor TS Tests Fuzzing Programs Testing CPIs & PDAs Testing Against a Validator Testing Best Practices

Deployment & Upgrades In Detail Deployment Basics Deploying Programs Program Upgrades Verifiable Builds (solana-verify)Making Programs Immutable Governance-Gated Upgrades Rollbacks & Incident Response Deployment Best Practices

Validator Ops Explained Validator Basics Agave Client Firedancer / Frankendancer Jito-Solana Hardware & Networking Vote Accounts & Staking Stake-Weighted QoS (SWQoS)Monitoring & Epoch Ops Validator Best Practices

Ecosystem & Team

Python for Solana Python for Solana Basics solders & solana-py Building Transactions in Python AnchorPy Reading Chain Data Trading & Bots Data Analysis Python for Solana Best Practices

Essential Crates solana-program & solana-sdk anchor-lang & anchor-spl spl-token & spl-associated-token-account borsh & bytemuck mpl-core & mpl-token-metadata pinocchio & steel @solana/kit, Codama & gill (JS/TS)litesvm, mollusk & solana-bankrun Essential Libraries Best Practices

Team Onboarding Key Points Onboarding Devs Checklist Environment Setup Checklist The Solana Mental-Model Ramp First Program & dApp Code Review Guidelines Team Best Practices

Tech-Lead Craft

Incident Response In Depth Debugging Failed Transactions Transactions Not Landing RPC & Infrastructure Outages On-Chain Incident Response Blameless Post-Mortems & RCA Rollback & Mitigation Prevention Checklists

Enterprise Delivery Blueprint Devnet to Mainnet Promotion Program Upgrade Strategy Feature Flags & Progressive Rollout Rollback & Forward-Fix DORA Metrics for Web3 Frontend Release Management Delivery Best Practices

Technical Leadership In Detail Technical Decision-Making Architecture Decision Records (ADRs)Running Design Reviews Code Review Culture Mentoring & Leveling Delegation & Spreading Context Handling Technical Disagreements Leadership Best Practices

Stakeholder Collaboration Key Points Requirements to Technical Specs Prioritizing Platform & Tech Debt Estimation & Risk Roadmap Contributions Stakeholder Communication Making the Process Work (Scrum/Kanban/SAFe)Product Collaboration Best Practices

Case Studies Blueprint Reference: A DeFi Program + dApp Reference: An SPL Token Launch Reference: A Compressed-NFT Mint at Scale Before/After: Optimizing a Program for CU & Rent Before/After: Making Transactions Land Reliably Security Incident Retrospectives Lessons-Learned Catalog

Standards & Future-Proofing Coding & Program Standards Documentation Conventions Contribution Guidelines Dependency & Crate Governance Audit & Bug-Bounty Program Tracking Ecosystem Change Spikes, PoCs & Adopting New Tools Governance Best Practices

More

Conceptos básicos de Anchor

Noções Básicas de Anchor

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Terms

An independent, unofficial educational resource. Not affiliated with, endorsed, or sponsored by the brand/trademark maintainers/owners.

Search Documentation

Search across all documentation pages

Solana SME/Tags/Rust

#Rust440 pages

Pages tagged Rust across 55 sections.

Account Discriminators Borsh Structs Data Versioning & Migration realloc & Growing Accounts Serialization Basics Serialization Best Practices Space Calculation Zero-Copy Accounts

Account Anatomy Account Model Basics Account Model Best Practices Account Ownership & Permissions Creating & Closing Accounts Data Accounts & Layout Program-Owned State Rent & Rent-Exemption System Accounts vs. Program Accounts

Accounts & Constraints

Account Types Account Validation Order Accounts & Constraints Best Practices Custom Constraints init & init_if_needed Seeds & Bump Constraints Space & Rent The #[account] Constraints Token & Associated Token Constraints

Advanced Anchor

Advanced Anchor Best Practices CU & Size Optimization Custom Account Types Feature Flags & cfg Interacting with Native/Pinocchio Programs realloc in Anchor remaining_accounts Zero-Copy Accounts

Anchor Basics Anchor Basics Best Practices Anchor vs Native Building & Deploying Project Structure The #[program] Module The Accounts Struct The Anchor Workflow

Before/After: Making Transactions Land Reliably Before/After: Optimizing a Program for CU & Rent Lessons-Learned Catalog Reference: A Compressed-NFT Mint at Scale Reference: A DeFi Program + dApp Reference: An SPL Token Launch Security Incident Retrospectives

Confirmation Levels in Clients Consensus Basics Consensus Best Practices Introducing Alpenglow Migration & Developer Impact Rotor TowerBFT + PoH Vote Accounts & Voting Votor

Architecture Best Practices Architecture Overview Cloudbreak & Accounts DB Gossip & Cluster Communication Gulf Stream Leader Schedule & Block Production Pipelining (TPU/TVU)Proof of History (PoH)Sealevel Turbine

Composability Patterns CPI Basics CPI Best Practices CPI Depth & Limits CPI to SPL Token CPI to the System Program invoke vs invoke_signed Passing Accounts to CPIs Reentrancy & Safety

CPI Basics in Anchor CPI Safety CPI to Custom Programs CPIs in Anchor Best Practices Passing Remaining Accounts Signed CPIs SPL Token CPIs

AMMs (Raydium, Orca, Meteora)DeFi Basics on Solana DeFi Integrations Best Practices Jito & MEV Lending & Borrowing Liquid Staking (LSTs)Oracles Perps & Order Books Swaps with Jupiter

Deploying Programs Deployment Basics Deployment Best Practices Governance-Gated Upgrades Making Programs Immutable Program Upgrades Rollbacks & Incident Response Verifiable Builds (solana-verify)

Economics Basics Economics Best Practices Governance & SIMDs Inflation & Staking Rewards Liquid Staking & LSTs MEV on Solana Priority Fee Markets Realms & On-Chain Governance Staking & Delegation

Enterprise Delivery

Delivery Best Practices Devnet to Mainnet Promotion DORA Metrics for Web3 Feature Flags & Progressive Rollout Frontend Release Management Program Upgrade Strategy Rollback & Forward-Fix

#[error_code] & require!Client-Side Error Decoding Custom Error Messages emit_cpi! & Self-CPI Events Errors & Events Best Practices Events with emit!Logging & CU Cost

Conceptos básicos de Anchor

@solana/kit, Codama & gill (JS/TS)anchor-lang & anchor-spl borsh & bytemuck Essential Libraries Best Practices litesvm, mollusk & solana-bankrun mpl-core & mpl-token-metadata pinocchio & steel solana-program & solana-sdk spl-token & spl-associated-token-account

Codama from an Anchor IDL Codegen Best Practices declare_program!Generating TS Clients IDL Versioning On-Chain IDLs The Anchor IDL

Analytics & Dashboards Building an Indexer Geyser Plugins Indexing Basics Indexing Best Practices Parsing Program Data Webhooks Yellowstone gRPC

Accessing Accounts Instruction Arguments Instruction Handlers Instruction Ordering & Dependencies Instructions Best Practices Return Values & CPIs from Handlers The System & Token Programs

Cloning Mainnet Accounts Loading Programs & Fixtures Local Dev Basics Local Dev Best Practices Local Logs & Debugging Localnet vs Devnet Workflow solana-test-validator Surfpool

Native Programs

Creating Accounts via CPI Emitting Logs Instruction Data (de)Serialization Manual Account Validation Native Program Basics Native Programs Best Practices Reading & Writing Account Data The Entrypoint & Dispatch When to Go Native

API Routes for Transactions Caching & Realtime Client-Side Signing dApp Integration Basics dApp Integration Best Practices Displaying On-Chain Data Providers & App Router Server-Side Reads Transaction UX

NFTs & Metaplex

Candy Machine Collections & Verification Metadata & Storage Metaplex Core NFT Basics on Solana NFT Best Practices Reading NFTs (DAS API)Royalties & Enforcement Token Metadata

Program Patterns

Access Control & Authorities Account Initialization Patterns Fee & Treasury Patterns Program Patterns Basics Program Patterns Best Practices State Machines On-Chain Time & Clock Upgrade-Safe Data Design Vault & Escrow

Client-Side PDA Derivation Common PDA Mistakes PDA Authorities PDAs in Anchor PDAs in Anchor Best Practices Signing with PDAs Storing Bumps

Pinocchio & Steel

Building a Program with Pinocchio CU & Binary-Size Wins Interop & Migration Lightweight Frameworks Best Practices Lightweight Frameworks Overview Pinocchio Basics Steel Framework When to Use Which Framework

Tx Optimization

Address Lookup Tables in Practice Estimating Compute Units Jito Bundles Optimization Best Practices Retries & Blockhash Management Setting Priority Fees Transaction Assembly Why Transactions Fail to Land

Product & Stakeholders

Estimation & Risk Making the Process Work (Scrum/Kanban/SAFe)Prioritizing Platform & Tech Debt Product Collaboration Best Practices Requirements to Technical Specs Roadmap Contributions Stakeholder Communication

Incident Response

Blameless Post-Mortems & RCA Debugging Failed Transactions On-Chain Incident Response Prevention Checklists Rollback & Mitigation RPC & Infrastructure Outages Transactions Not Landing

Canonical Bumps Deriving PDAs PDA Account Creation PDA Basics PDA Best Practices PDA Security Pitfalls PDAs as Authorities Seed Design & Collisions Signing with PDAs

Custom Error Enums Debugging Failed Transactions Decoding Errors Off-Chain Emitting Events Error Handling Basics Errors & Logs Best Practices Logging with msg!

Account Validation Attacks Arithmetic & Overflow Audit Workflow CPI & Reentrancy Risks PDA & Seed Attacks Reinitialization Attacks Sealevel Attacks Catalog Security Basics Security Best Practices Signer & Owner Checks

Sealevel Runtime

Account Locks & Conflicts Compute Units & Budgets Program Loaders & Upgradeability Programs Basics Sealevel Parallel Execution Sealevel Runtime Best Practices Stateless Programs The Program Entrypoint The SVM & sBPF

Noções Básicas de Anchor

AnchorPy Building Transactions in Python Data Analysis Python for Solana Basics Python for Solana Best Practices Reading Chain Data solders & solana-py Trading & Bots

Core RPC Methods getProgramAccounts & Filters Pagination & Efficiency Priority Fee & Simulation APIs RPC Basics RPC Best Practices RPC Providers The DAS API WebSocket Subscriptions

Borsh Serialization Error Handling On-Chain no_std & the Program Environment Program Size & CU Discipline Rust for Solana Basics Rust for Solana Best Practices Rust for Solana Programs Safe Arithmetic Working with Pubkeys & Accounts Zero-Copy with bytemuck

Airdrops & Balances Deploying Programs Inspecting Accounts & Programs Keypairs with solana-keygen Logs & Debugging Sending SOL & Transactions Solana CLI Basics Solana CLI Best Practices spl-token CLI

Clusters & Networks How a Transaction Flows Keypairs & Addresses Slots, Blocks & Epochs SOL, Lamports & Units Solana Basics Solana Fundamentals Best Practices The Solana Mental Model vs. EVM Wallets & Explorers

@solana/kit Basics @solana/kit Best Practices Address Lookup Tables Building Transaction Messages Codecs & Serialization Keypairs & Signers Migrating from web3.js v1 RPC & Subscriptions Signing & Sending

Building a Mobile dApp Deep Links & Session Handling Mobile Wallet Adapter (MWA)Seed Vault & Security Solana Mobile Basics Solana Mobile Best Practices The dApp Store

Actions (the spec)Blinks Building an Action Security & Verification Solana Pay & Actions Best Practices Solana Pay Basics Transaction Requests

Associated Token Accounts (ATAs)Authorities Decimals & Amounts Minting & Burning SPL Token Basics SPL Token Best Practices SPL Token in Programs Transfers & Delegates Wrapped SOL

Audit & Bug-Bounty Program Coding & Program Standards Contribution Guidelines Dependency & Crate Governance Documentation Conventions Governance Best Practices Spikes, PoCs & Adopting New Tools Tracking Ecosystem Change

Compressed NFTs (Bubblegum)Compression Best Practices Cost & Trade-offs How Compression Works Reading Compressed Assets (DAS)State Compression Basics Transferring cNFTs

Code Review Guidelines Environment Setup Checklist First Program & dApp Onboarding Devs Checklist Team Best Practices The Solana Mental-Model Ramp

Tech Leadership

Architecture Decision Records (ADRs)Code Review Culture Delegation & Spreading Context Handling Technical Disagreements Leadership Best Practices Mentoring & Leveling Running Design Reviews Technical Decision-Making

Anchor TS Tests Bankrun (TS)Fuzzing Programs LiteSVM Mollusk Testing Against a Validator Testing Basics Testing Best Practices Testing CPIs & PDAs

Confidential Transfers Interest-Bearing & Default Account State Metadata & Metadata Pointer Migrating from SPL Token Permanent Delegate & Non-Transferable Token-2022 Basics Token-2022 Best Practices Transfer Fees Transfer Hooks

Building Programs (cargo build-sbf)create-solana-dapp Editor & rust-analyzer Setup Mucho CLI Toolchain Best Practices Toolchain Overview Verifiable Builds (solana-verify)Version Management (agave-install / avm)

Transactions & Fees

Address Lookup Tables (ALTs)Blockhashes & Expiry Instructions & Accounts Jito Tips & Bundles Priority Fees Simulating Transactions The Compute Budget Program Transactions Basics Transactions Best Practices Versioned Transactions (v0)

Building Instructions Codama Fetching & Decoding Accounts gill Keeping Clients in Sync The Anchor TS Client Typed Clients Basics Typed Clients Best Practices

Agave Client Firedancer / Frankendancer Hardware & Networking Jito-Solana Monitoring & Epoch Ops Stake-Weighted QoS (SWQoS)Validator Basics Validator Best Practices Vote Accounts & Staking

@wallet-ui/react Autoconnect & Session UX Connecting & Disconnecting Hardware & Mobile Wallets Signing Transactions & Messages Wallet Adapter Wallet Basics Wallet Integration Best Practices

Related tags

List Best Practices Basics Advanced Accounts Cpi Anchor Security