Solana Developer Glossary

Every piece of data on Solana is stored in an account. Unlike Ethereum where contracts and data are intertwined, Solana separates programs (executable accounts) from data accounts. Each account has an owner (a program), a balance in lamports, and arbitrary data. Accounts must maintain a minimum balance (rent exemption) to persist on-chain.

Anchor is a framework for Solana smart contract development that provides IDL generation, automatic client SDK generation, account validation macros (#[account(...)]), and structured error handling. It significantly reduces boilerplate and prevents common security vulnerabilities. The Anchor workspace includes testing utilities and deployment tools. Most production Solana programs use Anchor.

An Associated Token Account is a PDA derived from a wallet address and token mint, providing a canonical token account address. Instead of users managing multiple arbitrary token accounts, each wallet has exactly one ATA per token type. ATAs are created with the createAssociatedTokenAccountInstruction instruction. Most token transfers use ATAs as the destination.

An AMM is a type of DEX that uses algorithmic pricing instead of order books. The most common formula is x*y=k (constant product), where x and y are token reserves. When you trade, you change the reserve ratio, which changes the price. Solana AMMs include Raydium (CPMM and CLMM), Orca (Whirlpools), and Meteora. AMMs enable permissionless liquidity provision and 24/7 trading.

Account validation is the critical security practice of verifying all account properties before using them: owner (correct program owns the account), signer (required signers have signed), data (account contains expected data), key (account address matches expected PDA), and writable (account can be modified). Anchor's #[derive(Accounts)] struct with constraints automates most validation. Missing validation is the most common source of Solana program vulnerabilities.

Address Lookup Tables allow transactions to reference accounts by 1-byte index instead of 32-byte pubkey, dramatically increasing the number of accounts that can be included in a single transaction. ALTs are on-chain accounts that store up to 256 addresses. They must be created and extended before use, and activate after approximately 1 slot. Essential for complex DeFi transactions that exceed the standard 32-account limit.

Berkeley Packet Filter (BPF), specifically its extended version (eBPF), is the bytecode format that Solana programs are compiled to. Rust, C, and C++ programs are compiled to BPF bytecode before deployment. The BPF virtual machine provides a sandboxed execution environment with deterministic compute costs.

A Jito bundle is a sequence of up to 5 transactions that are executed atomically at the beginning of a block. If any transaction in the bundle fails, all are reverted. Bundles are submitted to Jito's block engine with a tip (payment to the validator). Bundles enable MEV strategies like arbitrage and liquidations that require atomic execution of multiple transactions. Approximately 60-70% of Solana validators run Jito, making bundles widely available.

A bonding curve is a smart contract that automatically sets token price based on the current supply using a mathematical formula. As more tokens are bought, the price increases along the curve; as tokens are sold, the price decreases. Pump.fun uses a linear bonding curve. Bonding curves enable fair launches without pre-sales or VCs, but also enable sniping strategies.

Bankrun is a testing framework for Solana programs that simulates the Solana runtime without starting a full validator. Tests run 100x faster than with solana-test-validator. Bankrun supports time manipulation (setClock), account injection, and program deployment. It is ideal for unit testing individual program instructions. Use solana-test-validator for integration tests that need the full validator environment.

A Solana cluster is a group of validators that collectively maintain a distributed ledger. The main clusters are mainnet-beta (production), devnet (development), and testnet (validator testing). Each cluster is independent with its own genesis block and validator set.

Solana has three commitment levels: processed (seen by at least one validator, can be rolled back), confirmed (voted on by supermajority of stake, very unlikely to be rolled back), and finalized (maximum lockout, cannot be rolled back). Use confirmed for most reads and finalized for irreversible operations.

Compute units measure the computational work performed by a transaction. Each instruction type has a fixed CU cost. The default transaction limit is 200,000 CUs, adjustable up to 1,400,000 CUs via ComputeBudgetProgram. Priority fees are denominated in microLamports per compute unit, making CU optimization directly tied to transaction cost.

A CPI occurs when a program calls another program's instruction within the same transaction. CPIs allow composability — programs can build on each other's functionality. The calling program can sign for PDAs it controls during a CPI. CPIs have a depth limit of 4 (a program can call a program that calls a program that calls a program). Each CPI consumes additional compute units.

A CLMM allows liquidity providers to concentrate their capital within specific price ranges, earning higher fees when the price is within their range. This is more capital-efficient than traditional AMMs but requires active management. Orca's Whirlpools and Raydium's CLMM are the main CLMM implementations on Solana. Inspired by Uniswap v3.

Compressed NFTs use Solana's state compression (concurrent Merkle trees) to store NFT data off-chain with only the Merkle root on-chain. This reduces minting cost from ~0.012 SOL to ~0.000005 SOL per NFT — enabling collections of millions or billions of items. Used by Drip Haus, gaming platforms, and loyalty programs. Requires Merkle proofs for transfers.

ClickHouse is an open-source column-oriented OLAP database designed for analytical workloads. For Solana indexing, it offers: 1M+ rows/second write throughput, millisecond queries on billions of rows, 8-12x compression ratios, and materialized views for real-time aggregations. Its MergeTree engine with proper sort keys enables efficient time-series queries. ClickHouse is the recommended database for any Solana indexer processing more than 10 million transactions.

A DEX enables token trading without a central intermediary. On Solana, major DEXes include Raydium (largest by volume), Orca (concentrated liquidity), Meteora (dynamic liquidity vaults), and Phoenix (central limit order book). Jupiter aggregates liquidity across all DEXes to find optimal swap routes. DEXes on Solana process millions of trades daily due to low fees and fast confirmation.

DAS is an API standard for querying digital asset (NFT) data on Solana, providing a unified interface for both regular and compressed NFTs. Key methods: getAsset, getAssetsByOwner, getAssetsByCreator, searchAssets. DAS is implemented by Helius, Triton One, and other providers. It's the recommended way to query NFT ownership and metadata, especially for compressed NFTs which cannot be queried via standard RPC.

An epoch is a fixed period of slots (432,000 slots ≈ 2-3 days) during which the validator leader schedule is predetermined. Staking rewards are distributed at epoch boundaries. RPC nodes typically retain transaction history for ~2 epochs. Epoch transitions are important for staking operations and for understanding data retention limits.

On Solana, a transaction reaches finality when it achieves 'finalized' commitment — maximum lockout in Tower BFT consensus. This takes approximately 13 seconds. For most applications, 'confirmed' commitment (800ms) provides sufficient security. Unlike Ethereum's probabilistic finality, Solana's Tower BFT provides deterministic finality.

Solana forks occur when validators disagree on the canonical chain. Unlike Ethereum, Solana forks are common and expected — they are resolved through Tower BFT voting. Transactions on forked slots may be rolled back. Indexers and applications must handle forks by tracking slot status and reverting data for orphaned slots.

A flash loan allows borrowing any amount of tokens without collateral, as long as the loan is repaid within the same transaction. If repayment fails, the entire transaction reverts. Flash loans enable capital-efficient arbitrage, liquidations, and collateral swaps. On Solana, flash loans are available through protocols like Solend and Marginfi.

The Geyser plugin interface allows external processes to receive real-time data directly from a validator's memory. Plugins receive account updates, transaction notifications, and slot status changes as they occur — before data is written to disk. Yellowstone gRPC is the most widely used Geyser plugin, exposing a gRPC server for client subscriptions. Essential for building low-latency trading infrastructure.

gRPC (Google Remote Procedure Call) is a high-performance RPC framework using Protocol Buffers for serialization. For Solana, gRPC (via Yellowstone) provides streaming data access with 3-10x better efficiency than JSON-RPC WebSockets. Binary serialization, bidirectional streaming, and server-side filtering make it the standard for production trading applications. Providers like Supanode and Triton One offer managed Yellowstone gRPC endpoints.

Gulf Stream is Solana's transaction forwarding protocol that eliminates the traditional mempool. Validators forward transactions directly to the expected next leader, allowing validators to execute transactions ahead of time. This reduces confirmation times and memory pressure on validators. The downside: transactions can expire if the expected leader changes, requiring resubmission.

Helius provides premium Solana RPC infrastructure with additional developer tools: enhanced transaction parsing (human-readable transaction data), DAS API (Digital Asset Standard for NFTs), webhooks (real-time notifications), and priority fee APIs. Helius is particularly popular for NFT applications and developers who need enriched transaction data without building their own parser.

An IDL is a JSON file generated by Anchor that describes a program's instructions, accounts, types, and errors. It enables automatic client SDK generation — you can call program instructions with type-safe TypeScript code without manually constructing instruction data. IDLs are stored on-chain (in a PDA) and can be fetched by tools like Solana Explorer to display human-readable transaction data.

An indexer processes blockchain data (transactions, account updates) and stores it in a queryable database. Indexers transform raw blockchain data into structured records optimized for application queries. Types: account-based (tracks account state changes), transaction-based (parses transaction instructions), event-based (captures program events). Production indexers combine real-time streaming with historical backfill.

Jito provides MEV (Maximal Extractable Value) infrastructure for Solana. The Jito-Solana validator client (~60-70% of stake) supports transaction bundles — groups of transactions that execute atomically. Searchers submit bundles with tips to Jito's block engine. Jito also provides Shredstream for early transaction visibility and MEV protection features.

Jupiter is the primary liquidity aggregator on Solana, routing swaps through the best available paths across all major DEXes. It handles complex multi-hop routes (e.g., USDC→SOL→BONK when direct USDC→BONK liquidity is thin), split routes, and price impact minimization. Jupiter also offers limit orders, DCA (Dollar Cost Averaging), and perpetuals. Most Solana wallets and applications use Jupiter for swaps.

A lamport is the smallest denomination of SOL, named after computer scientist Leslie Lamport. 1 SOL = 1,000,000,000 lamports (10^9). All on-chain balances and fees are denominated in lamports. The base transaction fee is 5,000 lamports. Rent exemption for a typical account is ~2,000,000 lamports (0.002 SOL).

The leader is the validator scheduled to produce blocks for the current slot. The leader schedule is determined at the start of each epoch based on stake weights. Each validator gets leader slots proportional to its stake. Being the leader is how validators earn transaction fees. The leader schedule is public and deterministic, allowing clients to forward transactions directly to the upcoming leader.

MEV refers to the maximum value that can be extracted from block production beyond standard block rewards and fees. On Solana, MEV strategies include DEX arbitrage (exploiting price differences), liquidations (liquidating undercollateralized positions), and sandwich attacks (front-running and back-running user trades). Jito's infrastructure enables and partially organizes MEV extraction on Solana.

Metaplex provides the core NFT infrastructure on Solana: Token Metadata program (stores NFT name, symbol, URI, royalties), Candy Machine (fair launch mechanism), Core (next-gen NFT standard), and Bubblegum (compressed NFTs). The @metaplex-foundation/umi TypeScript library is the modern client. Metaplex programs are used by virtually all NFT projects on Solana.

A materialized view is a database object that stores the results of a query, updated automatically when source data changes. In ClickHouse, materialized views are triggered on INSERT and can pre-aggregate data in real-time. For Solana indexers, materialized views compute metrics like daily volume, token holder counts, and price OHLCV as data arrives — enabling millisecond query response times for dashboards.

Marinade Finance is Solana's leading liquid staking protocol. Users deposit SOL and receive mSOL (Marinade Staked SOL), which automatically accrues staking rewards. mSOL can be used in DeFi while still earning staking yield. Marinade delegates stake across 450+ validators using an algorithmic strategy that optimizes for decentralization and performance.

An owner check verifies that an account's owner field matches the expected program ID. Without this check, an attacker could pass a malicious account with the same data layout but owned by a different program. In Anchor, the #[account] attribute automatically performs owner checks. Always verify account ownership before deserializing account data.

OLAP (Online Analytical Processing) databases are optimized for complex analytical queries over large datasets, as opposed to OLTP (Online Transaction Processing) databases optimized for many small reads/writes. ClickHouse is an OLAP database. Key OLAP characteristics: columnar storage (reads only needed columns), compression, vectorized execution, and batch inserts. For Solana analytics, OLAP databases handle the billions of transactions and account updates efficiently.

A PDA is an account address derived from a program ID and seeds using SHA-256 hashing, intentionally placed off the Ed25519 curve (no private key exists). Programs can 'sign' for PDAs using their program ID. PDAs are used for program-controlled accounts: escrows, protocol treasuries, user state accounts, and any data the program needs to own and control.

Proof of History is a verifiable delay function using sequential SHA-256 hashing. Each hash's output becomes the next hash's input, creating an immutable record of time passage. This allows validators to agree on transaction ordering without communicating about timestamps, enabling Solana's high throughput. PoH works alongside Tower BFT consensus.

Priority fees (set via ComputeBudgetProgram.setComputeUnitPrice) are denominated in microLamports per compute unit. They allow transactions to jump ahead in the validator's queue during congestion. Total priority fee = microLamports × compute units / 1,000,000. Use getRecentPrioritizationFees() to query current market rates. During high congestion, priority fees can be 100-1000x the base fee.

Pump.fun is a permissionless token launchpad that allows anyone to create and trade meme tokens using a bonding curve mechanism. Tokens start with a fixed supply and a bonding curve that increases price as more tokens are bought. When the market cap reaches approximately $69K, liquidity migrates to Raydium. Pump.fun has launched millions of tokens and drives significant Solana network activity.

Pyth Network is a first-party oracle protocol that aggregates price data from 90+ institutional market makers and exchanges. It provides sub-second price updates for 500+ assets including crypto, equities, FX, and commodities. Pyth's confidence intervals indicate data quality. It is the primary oracle for DeFi protocols on Solana requiring reliable price data for lending, derivatives, and trading.

Solana charges rent for storing data on-chain, proportional to account size and time. Accounts maintaining a minimum balance (rent exemption threshold) are exempt from ongoing rent charges. The rent exemption for a 0-byte account is ~890,880 lamports; each additional byte costs ~6,960 lamports. Accounts below the exemption threshold are eventually purged.

Solana's RPC API is a JSON-RPC 2.0 interface exposing ~50 methods for reading blockchain state and submitting transactions. Key methods: getAccountInfo, getTransaction, sendTransaction, getLatestBlockhash, getProgramAccounts. The public endpoint (api.mainnet-beta.solana.com) is rate-limited. Production applications use premium providers like Helius, Supanode, QuickNode, or HighTower for higher limits and better reliability.

Raydium is Solana's leading AMM and DEX, offering CPMM (constant product), CLMM (concentrated liquidity), and CPSWAP pools. It is the primary destination for Pump.fun token graduations and handles the majority of Solana DEX volume. Raydium also integrates with OpenBook order book for hybrid AMM/order book liquidity.

A slot is approximately 400ms — the time allocated for a validator to produce a block. Not every slot produces a block (some are skipped). Slots are numbered sequentially from genesis. The slot skip rate is typically 5-15%. Block time is measured in slots, and most time-based operations on Solana use slot numbers rather than wall clock time.

SPL Token is Solana's standard for fungible tokens, analogous to ERC-20 on Ethereum. All fungible tokens (including SOL-wrapped tokens, stablecoins, and meme tokens) use the SPL Token program. Token-2022 is the successor with additional features (transfer fees, interest-bearing tokens, confidential transfers). Each token type has a 'mint' account defining supply and decimals, and users hold tokens in 'token accounts'.

Slippage occurs when the actual execution price differs from the quoted price, typically due to price movement between quote and execution, or insufficient liquidity. In AMMs, larger trades cause more slippage due to the constant product formula. Slippage tolerance is set as a percentage — if slippage exceeds the tolerance, the transaction reverts. Typical settings: 0.5% for stable pairs, 1-3% for volatile tokens, higher for low-liquidity tokens.

Shredstream delivers raw shred data — the atomic units of Solana block propagation — before transactions are confirmed. Shreds are 1,228-byte data packets that validators broadcast as they produce blocks. Shredstream subscribers receive this data 50-200ms before it's available via gRPC, enabling the earliest possible transaction visibility. Used primarily for MEV extraction and ultra-low latency trading strategies. Available through Jito and specialized providers.

Substreams is a streaming data processing framework developed by StreamingFast (now part of The Graph ecosystem) that enables parallel processing of blockchain data. Substreams modules define data transformations that run close to the data source, enabling efficient large-scale indexing. Available for Solana, enabling developers to build custom data pipelines with reusable modules.

A signer check verifies that an account marked as a signer actually provided a valid signature for the transaction. Missing signer checks are one of the most common Solana program vulnerabilities — without them, anyone can call instructions that should be restricted to authorized parties. In Anchor, use the Signer type or #[account(signer)] constraint to enforce signer checks automatically.

Sealevel is Solana's parallel smart contract runtime that executes non-overlapping transactions simultaneously. Transactions declare all accounts they will read and write upfront, allowing the runtime to identify non-conflicting transactions and execute them in parallel across multiple CPU cores. This is a key reason Solana can achieve high throughput — most transactions do not touch the same accounts.

A shred is a ~1,228-byte packet that is the atomic unit of Solana block propagation. Blocks are broken into data shreds and coding shreds (for erasure recovery). Shreds are broadcast by the leader through the Turbine tree. Shredstream services deliver raw shreds to subscribers before block finalization, providing the earliest possible data access — critical for MEV and latency-sensitive trading.

Squads Protocol provides multi-signature wallet infrastructure for Solana. It enables teams to require multiple approvals for transactions, program upgrades, and treasury management. Squads supports time-locks, spending limits, and role-based permissions. It is the standard solution for securing protocol upgrade authorities, team treasuries, and any high-value operations requiring multi-party authorization.

Tower BFT is Solana's consensus algorithm, a variant of PBFT optimized for PoH. Validators vote on forks, with each vote increasing a lockout period that grows exponentially. This makes switching to a different fork increasingly costly over time, providing economic finality. Tower BFT enables Solana to achieve consensus with minimal communication overhead.

Turbine is Solana's block propagation protocol inspired by BitTorrent. The leader breaks blocks into small shreds (~1KB) and distributes them through a tree of validators. Erasure coding adds redundant shreds so blocks can be reconstructed even if some are lost. This enables efficient propagation of large blocks across thousands of validators without requiring each validator to receive data directly from the leader.

Triton One is a Solana infrastructure company that created the Yellowstone gRPC plugin — the standard for Solana data streaming. They provide premium RPC nodes, gRPC endpoints, and the open-source Yellowstone implementation used by most Solana gRPC providers. Triton One is known for its technical contributions to the Solana ecosystem.

Token-2022 (Token Extensions) is the successor to the original SPL Token program, adding optional extensions: transfer fees (automatic fee on each transfer), interest-bearing tokens (tokens that accrue interest), confidential transfers (privacy-preserving transfers using ZK proofs), non-transferable tokens (soulbound), and metadata extension (store metadata directly in mint). Token-2022 is backward-compatible with SPL Token wallets and DEXes.

Validators are the backbone of the Solana network. They process transactions, produce blocks (when selected as leader), vote on forks, and maintain the ledger. Validators stake SOL to participate in consensus and earn rewards. The leader schedule determines which validator produces blocks in each slot. Running a validator requires significant hardware and bandwidth.

Versioned transactions (v0) are the modern Solana transaction format that supports Address Lookup Tables (ALTs). Legacy transactions are limited to 32 accounts per transaction; versioned transactions with ALTs can reference up to 256 accounts using 1-byte indices. Required for complex DeFi transactions (Jupiter swaps, multi-DEX arbitrage) that touch many accounts. Use TransactionMessage.compileToV0Message() with ALT accounts.

Wormhole is a generic cross-chain messaging protocol connecting Solana to 20+ blockchains including Ethereum, BNB Chain, Polygon, and Avalanche. It uses a guardian network of 19 validators to sign cross-chain messages (VAAs — Verified Action Approvals). Wormhole enables token bridging, cross-chain NFTs, and cross-chain governance. It is the most widely used bridge for Solana.

Yellowstone gRPC is an open-source Geyser plugin implementation developed by Triton One that exposes a gRPC server for real-time Solana data streaming. It supports filtering by account, program, or transaction type server-side, reducing bandwidth requirements. The Yellowstone client library (@triton-one/yellowstone-grpc) provides TypeScript bindings. Most Solana gRPC providers use Yellowstone as their underlying implementation.