Articles & deep dives
Technical writing on Solana — programs, tooling, infrastructure, and the DevRel community.
Write for devrels.xyzvanity v0.8.0: keypair grinding gets the speed treatment — AVX-512 ed25519 and a tuned OpenCL path
The fastest Solana vanity grinder just made its slow path fast. v0.8.0 batches ed25519 keygen 8 lanes wide with AVX-512 IFMA on CPU and rebuilds the OpenCL keypair kernels — Montgomery batch inversion, a radix-32 comb for fixed-base scalarmult, fused base58 early-reject. Real signable vanity keypairs at 65M/s per 4090.
Where is Solana's ABI? Why your inline ethers.js habit doesn't port, and how Codama closes the gap
Every EVM developer hits this wall: on Ethereum you inline a function signature string and call the contract; on Solana you're handed a JSON IDL and told to run a code generator. The gap is real, it has a structural reason, and the tooling has quietly caught up. A field guide to IDLs, Codama, and the account model that makes inline ABIs impossible.
Orquestra: upload a Solana IDL, get a REST API, AI docs, and an MCP server
The IDL describes everything about a Solana program, so why are you still writing a backend to expose it? Orquestra takes an Anchor or Codama IDL and hosts the rest: REST endpoints for instructions and accounts, PDA derivation, an unsigned transaction builder, llms.txt for AI agents, and a public MCP server. A look at what it does and where it fits.
Credible Finance: T+0 settlement for the businesses card gateways decline
Card acquirers settle in three days; prediction markets and fintechs want money now. Credible Finance fronts that float with stablecoin liquidity pools, orchestrates 86+ pay-in methods across 42+ markets, and settles merchants T+0 in USDC, USDT, USD, EUR, or GBP. Colosseum-backed, $700M+ processed, $CRED ownership token live on MetaDAO. Architecture, developer surface, and the honest read.
The 10 most-invoked Solana programs, per ProgramWatch
Rank programs by what actually gets called on Solana and you get a different picture than TVL charts: SPL Token at 346M invocations a day, the Pump.fun stack summing to ~100M across three programs, Meteora's open-source DAMM v2 out-calling Jupiter, and — at #6 — a program that looks like anonymous bot infrastructure on every explorer but resolves to Phoenix Perps once you dig. Sourced from ProgramWatch's free API, then cross-checked against the OtterSec verify registry, Solana Compass, and each team's repos — which is where the real story turned out to be.
Solana vs Robinhood Chain, by the numbers
Yesterday we covered what Robinhood Chain is. Today, the tape measure: Solana is 6.3 years old with ~704 permissionless validators, 4,302 gossip nodes, 29 months since its last outage, $4.98B TVL, and 63,503 deployed programs. Robinhood Chain is 9 days old with one sequencer. That's not a dunk — it's a different design goal. The fairest comparison for the stack's ceiling is Arbitrum One, and the numbers tell that story too.
Unruggable: a Solana wallet that grew from a bash script into an ESP32 hardware signer
Most wallets optimize for onboarding; Unruggable optimizes for not getting drained. The project spans a pure-bash ATM-style CLI wallet, a Rust/Dioxus app for all five platforms with MPC instead of seed phrases, and an open-firmware ESP32 signer that only signs when you physically press the button. The first hardware run already sold out.
Robinhood Chain is live: what the broker's L2 means, and how it stacks up against Solana
Robinhood Chain's mainnet went live July 1 with 24/7 'Classic Stock Tokens' in 120+ countries — on an Arbitrum Orbit L2, not Solana. Here's the honest comparison: 100ms sequencer blocks vs Solana's L1 finality, a corporate single-sequencer chain vs a permissionless network, tokens with no shareholder rights vs Solana's own tokenized-equity scene, and why every big exchange now wants its own chain.
What hides what: Solana privacy solutions in one table
'Private' is doing a lot of work in Solana marketing right now. Confidential Transfers hide amounts but not who's transacting. Shielded pools hide both but can't compute. Arcium and MagicBlock compute on hidden data — one trusts math, the other trusts a chip. The right question isn't 'which is most private?' — it's 'what exactly do I need hidden, and whom am I willing to trust?' Here's the matrix.
PoH was scaffolding, not the building: Rotor, Votor, and the end of Solana's origin story
For years PoH was THE reason Solana was special. Now Alpenglow replaces it with direct votes and a relay layer, and the tempting take is 'PoH was always marketing.' That take is wrong in an interesting way. PoH did real work — it gave leaders a verifiable clock so they could stream blocks without waiting on consensus, which is a big part of why Solana shipped 400ms blocks when nothing else could. But it was never consensus. Tower BFT was, and it underdelivered for years. Here's the honest history: what PoH built, why Votor and Rotor make it unnecessary, and why binning your origin story is the strongest signal in the whole saga.
Solana agent skills, compared: the portal, the marketplace, the mono-skill, and VulnHunter
Type 'Solana skills' into a search bar and you land on four different things: an official directory with pinned commit hashes, a SendAI marketplace with 47 protocol skills, a Foundation mono-repo that teaches your agent the entire January-2026 dev stack in one install, and individual community skills like VulnHunter that are really security methodologies wearing a markdown file. They're not competitors — they're layers. Here's the map.
NVIDIA's open-model giveaway: the Nemotron 3 era, mapped for builders
The biggest open-weights supplier of 2026 isn't a lab — it's NVIDIA. Nemotron 3 (Nano 31.6B → Ultra ~550B, hybrid MoE), Parakeet/Canary for speech, Cosmos for physical AI, GR00T for robots, plus the training datasets and the inference stack. Here's the developer-resources map, the license reality, and why open weights matter for agents that hold keys.
Bank APIs for Solana apps: Bridge vs Sphere vs Squads Grid
The missing piece between 'we settle in USDC on Solana' and 'normal businesses can pay us' is a bank API: a virtual account with real routing details that auto-converts fiat deposits into stablecoins. Bridge (Stripe's $1.1B acquisition), Sphere, and Squads' Grid all sell this as a REST API. The pattern, the players, and how to choose.
Passkeys on Solana: how Face ID signs transactions now
Passkeys sign with P-256; Solana transactions require Ed25519. The secp256r1 precompile (SIMD-0075, live on mainnet since June 2025) bridges the gap — and enables wallets where the only key is the one in your phone's secure enclave. The spec, the smart-wallet pattern, and the two competing architectures.
ZK proofs on Solana: the two stacks, mapped
Zero-knowledge on Solana is two parallel stacks that share almost nothing: a curve25519 sigma-protocol stack purpose-built for confidential transfers, and a BN254 SNARK stack (alt_bn128 syscalls + Groth16) that powers ZK compression and general-purpose verifiers. Here's the full map — syscalls, programs, provers, costs, and the mid-2025 soundness bug that reshaped the roadmap.
Ed25519SigVerify111111111111111111111111111: Solana's signature-verification workhorse
Every Solana transaction verifies Ed25519 signatures over the transaction itself — but when your program needs to verify a signature over an arbitrary message (a signed voucher, an oracle price, a relayed intent), you need the Ed25519 precompile. It can't be CPI'd, its offsets are attacker-controlled, and getting the introspection check wrong is a classic exploit. The full reference.
OKX.AI Genesis Hackathon: $100K to seed the agent economy — settled on Solana
OKX.AI is a two-sided marketplace where AI agents discover work, hire other agents, and settle in USDT/USDG — with Solana as a payment rail. The Genesis Hackathon puts up $100K for the first wave of Agent Service Providers, and the submission window closes July 17. Here's the platform, the Solana angle, and how to enter.
Crypto philanthropy is a $100M/year rail — and it's buildable
The average crypto donation is $11,019 — an order of magnitude above typical online gifts — and volume grew 66% last year. Solana led crypto giving in MrBeast's #TeamWater. Here's how the rails work: The Giving Block's developer APIs (SOL + BONK/JUP/JTO/USDC supported), on-chain DAFs via Endaoment, and the Solana-native patterns (Pay QRs, donation Blinks).
Devnet, testnet, mainnet — Solana's clusters, and how to fund a devnet wallet
Solana runs three public clusters and beginners regularly deploy to the wrong one. Here's what devnet, testnet, and mainnet are actually for, plus the fastest way to get 20 devnet SOL (devnetfaucet.org) and 20 devnet USDC (Circle's faucet) into your wallet.
integrations.sh maps every integration agents can reach — and Solana isn't on the map
The hard part of agent integrations isn't discovery — it's auth. integrations.sh bets on that: a map of every service surface an agent can reach, each with a grounded credential guide and honest detected/discovered provenance, all served as one machine-readable api.json. Solana has the most mature agent tooling in crypto and yet appears nowhere in it. Here's the model, the verified gap, and what a Solana service should publish.
Securitize on Solana: how tokenized stocks and funds enforce compliance with Token-2022
SECZ went live on the NYSE and on Solana on the same day. On Solana every Securitize asset is a Token-2022 mint that enforces its own compliance — but the tokenized stock uses defaultAccountState + pausable + scaled UI amount, while the funds use a transfer hook. Here's what that means when you integrate them, with the real mainnet mints.
Cloudflare's Monetization Gateway runs on x402 — and Solana is a settlement rail
The largest edge network on earth just made HTTP 402 a product. The Monetization Gateway does metering, the payment exchange, and settlement at Cloudflare's edge — and it's built on x402, whose 'exact' scheme runs on Solana with USDC. For Solana x402 sellers, the origin middleware you run today can move to the edge, and the strategic signal is enormous.
Agave v4.2: 200ms slots, XDP by default, and what breaks for validators and RPC operators
Agave v4.2 branch cut June 29. Mainnet general adoption August 10. The headline: Anza is targeting 200ms slot times. The breaking changes: XDP transmit on by default (needs CAP_NET_ADMIN), blockstore legacy format removed, confidential transfer JSON fields renamed, vote-account CLI output changed.
Jito NCN and VRT mechanics: building Node Consensus Networks on Jito restaking
The restaking overview tells you jitoSOL earns extra yield. This article tells you how: NCNs are opt-in decentralized services that operators run in exchange for a slice of protocol fees, backed by slashable restaked SOL. Here is the account model, the registration lifecycle, and what it actually takes to ship an NCN.
Sanctum for developers: LST swap API, Gateway transaction delivery, and on-chain programs
Sanctum has 200+ LSTs and two developer products: a swap API at sanctum-api.ironforge.network (stake, unstake, swap any LST with slippage control and route filtering) and Gateway at gateway.sanctum.so (buildGatewayTransaction + sendTransaction — routes through Jito, SWQoS, Paladin, and refunds Jito tips if the tx lands via RPC).
Alchemy CLI: query blockchain data, send transactions, and manage apps from the terminal
npm i -g @alchemy/cli then alchemy auth. From there: balances, ERC-20 tokens, NFTs, swap, bridge, simulate, solana send, solana rpc, webhooks, app management — all from the terminal. --json and --no-interactive make every command pipeline-safe.
Auticuro vs Solana: two approaches to high-throughput account balance management
Airwallex open-sourced Auticuro — a Rust wallet service using Raft consensus, CQRS, and event sourcing that hits P99 < 20ms at 10K TPS on a 5-node cluster. Solana hits 65K+ TPS with 400ms finality on a permissionless network. Same class of problem, completely different trust assumptions. Here's the comparison.
Sign In With Solana: wallet-based auth from spec to session token
Your wallet is your identity. Sign In With Solana turns that into a real auth protocol: a structured message, a wallet signature, and a server that verifies the Ed25519 sig and issues a session. No email required. Here's how to implement the full stack — frontend signIn call, backend nonce management, signature check, and JWT — plus the security edge cases that trip people up.
Collector Crypt for builders: marketplace API, gacha VRF, and on-chain programs
Collector Crypt has a marketplace program (non-custodial, delegation-based), a gacha program with RFC 9381 VRF for provably fair pack opens, and a shipping API for physical card vault operations. API partnerships are rolling out. Here's what's available to build on today.
Backpack Exchange API: ED25519 auth, 70 endpoints, and the official Rust SDK
Backpack Exchange processes orders through a single linear command stream into one matching engine. The API uses ED25519 keypair auth — no API-key secrets, just public/private keypairs you control. REST at api.backpack.exchange, WebSocket at wss://ws.backpack.exchange. Official Rust SDK; community Python SDK on PyPI.
Sports data on Solana: how TxODDS puts verifiable odds on-chain and what you can build
TxODDS publishes Merkle roots of every data packet to Solana, making sports data tamper-evident and independently verifiable. Developers subscribe on-chain using TxL tokens (USDT → TxL → program subscription → API token), then query live odds, scores, and settlement feeds. Free tier covers the 2026 World Cup.
Solana verified program builds: reproducible bytecode and the on-chain registry
An audit report is worthless if you can't confirm the deployed bytecode is what was audited. Solana verified builds fix that: a Docker-pinned toolchain produces a deterministic .so, its hash is compared to the on-chain program data, and the result is written to a PDA anyone can read. Solana Explorer shows a verified badge. Here's the full workflow.
solana/pay: the missing payment layer for HTTP and AI agents
pay is a Rust CLI that acts as a transparent HTTP payment proxy. When any tool behind it hits a 402, pay detects whether it's x402 or MPP, prepares a USDC transaction, asks your local wallet (Touch ID on macOS) to sign it, then retries. Agents pay for APIs. You stay in control.
Brale: white-label stablecoin issuance infrastructure on Solana
Issuing a stablecoin used to mean becoming a stablecoin company — licensing, reserve management, custody, compliance. Brale collapses that into an API. Your brand, your stablecoin, Brale's regulated infrastructure underneath. On Solana it uses Token Extensions natively: transfer hooks for compliance checks, confidential transfers for privacy. SquareFi launched MainUSD across 150 countries without writing a mint program.
Zoneless: open-source Stripe Connect replacement on Solana
Stripe Connect costs $2/active account/month plus 0.25% + $0.25 per domestic payout and $1.50 per international. Zoneless replaces it with USDC on Solana: $0.002 in gas fees, instant settlement, same API shapes. PromptBase ran both in parallel — 72% of sellers chose Zoneless. It's Apache 2.0, self-hosted, and the SDK is a near-drop-in swap.
polymarket-rs: a typed Rust SDK for the Polymarket CLOB
polymarket-rs gives you a typed Rust interface to Polymarket's order book — ClobClient for unauthenticated market data, TradingClient for placing and managing orders, WebSocket clients for real-time streaming. No panics, newtype IDs, alloy-backed EIP-712 signing. Here's the full API surface and how to go from Cargo.toml to a live order.
Polymarket as a global truth machine: 10 things you can build with the API
Polymarket is not a betting site. It's the closest thing to a global consensus machine the internet has produced. When millions of dollars are behind a probability estimate, that estimate is load-bearing in a way no poll or pundit can match. The API exposes it. Here are 10 things you can build with it.
TypeScript 7.0 RC: the compiler is now Go, and it's 10x faster
TypeScript 7.0 ships a native Go compiler — 10x faster than 6.0, parallel checkers and builders, a rebuilt file watcher from Parcel's C++ watcher ported to Go. The tradeoff: new defaults (strict, esnext, noUncheckedSideEffectImports) and dropped targets (ES5, amd, umd, classic moduleResolution) that will break existing configs. Here's the full rundown.
The deploy gap: what Block's App Kit teaches Solana builders
Block's engineering team identified that AI shifted the bottleneck from building to deploying safely. 1,000+ internal apps, 80% non-engineer users, security-org endorsed. The same gap exists in every Solana team shipping internal tooling — treasury dashboards, validator monitors, DAO analytics. Here's the pattern.
Helius: enhanced transactions, webhooks, DAS API, smart transactions
Helius turns raw Solana transactions into human-readable events — NFT_SALE, SWAP, TOKEN_TRANSFER — and delivers them to your endpoint via webhooks. DAS API, smart transactions, priority fee estimates. The Yellowstone for people who don't want to run infra.
Eclipse: SVM execution on an Ethereum L2
What if you could write Anchor programs and deploy them to an Ethereum-settled chain? Eclipse does exactly that: SVM execution, Ethereum settlement, Celestia for data availability, and ETH as the gas token. Same Rust, same Anchor macros, different network.
Jupiter: the aggregation layer of Solana DeFi
Jupiter routes every swap through a live graph of Solana's AMMs, splits orders across pools, and executes via versioned transactions with embedded ALTs. Under that is the JLP vault backing perpetuals, an on-chain DCA program, a limit-order crank, and a community-gated token launchpad. Here's the full picture for builders integrating it.
Meteora DLMM: the concentrated liquidity layer behind Solana token launches
Meteora DLMM organises liquidity into discrete price bins instead of a continuous curve, charges fees that scale with volatility, and lets LPs choose a liquidity shape that matches their market view. Alpha Vault adds sybil-resistant purchase caps for fair launches. Here's how it all fits together for builders integrating it.
solana-keychain: one signing interface, 13 backends
Every production Solana app eventually has the same conversation: which wallet/KMS provider should we use? solana-keychain answers by making the choice irrelevant — one interface, feature-flagged backends, swap without rewriting signing code.
Solana Private Channels: enterprise payment infrastructure on Solana mainnet
A payment channel where assets stay on Solana mainnet but transactions are private, instant, and controlled by the operator. Not a separate chain, not a bridge — escrow locks SPL tokens, the channel processes thousands of transactions at ~100ms, and withdrawals burn back to mainnet. The reference architecture for tokenised deposits and institutional capital markets.
Solana RPC latency benchmarks, June 2026: what the public endpoint actually costs you
Benchmarked: Solana Foundation public RPC, Extrnode, and PublicNode across getSlot, getLatestBlockhash, getBalance, getEpochInfo, getSignaturesForAddress, and getTokenAccountsByOwner. The basic methods are similar. The indexing-heavy methods diverge by 4.5×. Published RPC 2.0 numbers push that to 24×.
Solana Skills: pre-built agent context for every Solana protocol
Every time you open a new Claude Code session and ask about Jupiter swaps or Helius webhook setup, the agent starts cold. Solana Skills fixes that: pre-built, protocol-specific context files you install once. Ask about Orca concentrated liquidity and the agent already knows the API shape.
Surfpool v1.4.0: Jito bundle simulation, slot subscriptions, and snapshot exports
v1.4.0 is the Jito-aware update: simulateBundle lets you test bundle execution locally before touching mainnet. Also new: slotUpdatesSubscribe WebSocket subscription, sysvar/feature-gate filters on snapshot export, and four bug fixes including correct memo and block_time in getSignaturesForAddress.
x402 and pay.sh: why pay-per-call beats API keys for agents and builders
Every API you use today requires an account, a key, a billing portal, and a rotation policy. x402 collapses that to one HTTP header. pay.sh implements it as a single binary that wraps curl — 76 providers across AI, data, compute, messaging, finance, and more. No keys to manage. No subscriptions.
The future of Solana: what's actually being built and why it matters
Solana's next chapter isn't one thing — it's a stack of simultaneous upgrades: Alpenglow (~150ms finality), Firedancer (second independent validator), RPC 2.0 (reads out of the validator), post-quantum prep, and an AI agent economy building on top. Here's what's real and when.
Earning the Solana retweet: a guide for builders
The @solana account amplifies builders, not promoters. What earns the retweet: substance over hype, concrete numbers, open-source contributions, and content that teaches the ecosystem something new. A practical guide for anyone building on Solana who wants distribution.
Turso and libSQL: the database that fits the Solana stack
Solana handles on-chain state. Turso handles everything else — user profiles, off-chain indexes, cached RPC data, leaderboards. Built on libSQL (a Rust-backed SQLite fork), it deploys to the edge, runs embedded locally, and speaks HTTP from Cloudflare Workers. Here's the architecture and the code.
Agave: what it is and why Solana's validator got renamed
Agave is the Solana Labs validator, renamed and rehomed under Anza. Here's what the rename actually changed, why it happened, and how Agave relates to Jito-Solana, Frankendancer, and Firedancer.
Solana RPC 2.0 and the RPC Working Group: rebuilding the read layer
RPC 2.0 removes reads from the Agave validator and rebuilds them as Cloudbreak (accounts) and Superbank (ledger) — open, AGPL modules with 5–38x benchmark wins. Here's the split, the neutral RPC org, and what changes for builders.
Mastercard Agent Pay for Machines: card rails for agents, permissions on Solana
Mastercard's Agent Pay for Machines puts the incumbent into agentic payments — but the interesting part isn't the card network, it's where the authorization lives. Agent permissions and credentials are written to public blockchains (Solana among the first three) as a 'Verifiable Intent' ledger anyone can audit, while settlement stays on Mastercard's network. A look at the architecture and how it sits beside x402.
x402 vs Mastercard AP4M: two bets on how agents pay
Both x402 and Mastercard's AP4M answer the same question — how does an agent pay without a human in the loop — and they answer it differently. One is an open HTTP status code settled in USDC on Solana; the other is a permissioned network that uses public chains only as a credential ledger. Here's the head-to-head, dimension by dimension, and a decision guide.
OpenFinance: one market API for agents — with Solana spot & DeFi
OpenFinance collapses many brokers and chains behind one API key for AI agents: crypto spot and perps, US equities, Polymarket, and DeFi. Solana is one of its three spot & DeFi chains. The notable design choice is non-custodial — the MCP server previews and builds transactions, but the agent signs and submits them. A look at the surface and the trust boundary.
MagicBlock by example: the delegate → ER → commit loop
Ephemeral Rollups sound exotic until you see the loop: it's one Anchor program, two RPC endpoints. You delegate a PDA to an ER validator, fire cheap 10ms transactions against it, then commit state back to Solana and undelegate. MagicBlock's examples repo is the cleanest way to learn it — here's the lifecycle in real code and a map of where to start.
Top Ledger's API: decoded Solana data by key or by x402
Top Ledger is the data layer behind a lot of Solana analytics. Its API serves decoded protocol data across DEX, lending, perps, LP, staking, and yield — and it ships two ways to call it: an API-key MCP/REST tier, and a keyless x402 endpoint that any agent can pay per call. A look at the surface and the two access models.
SolScript: write Solidity, compile to Solana
An EVM developer's biggest Solana hurdle isn't Rust — it's the account model. SolScript lets you write Solidity and compiles it to standard Anchor, auto-deriving PDAs from your mappings. Genuinely clever, and refreshingly honest (you can eject to Rust). Where it shines, and where the abstraction leaks.
Solana privacy in 2026: the four approaches
Solana is the most transparent it's ever been — and privacy tooling is finally catching up. Four distinct approaches now ship: Token-2022 encrypted balances, Arcium's MPC, shielded ZK pools like Privacy Cash, and TEEs inside Jito BAM and MagicBlock. A map of the landscape.
TEEs on Solana: confidential compute by trusting the chip
MPC trusts a node majority; ZK trusts math; TEEs trust the CPU vendor. That last bet is faster and more general than either — and it's already live on Solana inside Jito's BAM mempool, MagicBlock's private rollups, and Switchboard's oracles. How enclaves and attestation actually work.
Private payments on Solana after Elusiv
Solana's biggest privacy protocol, Elusiv, shut down in 2024 — and its team rebranded into Arcium. So what moves money privately on Solana now? Token-2022 confidential transfers, Umbra's shielded pool, and Privacy Cash's $400M ZK mixer. The post-Elusiv map, and the compliance shift underneath it.
Compliant privacy on Solana: viewing keys and selective disclosure
The privacy that ships on Solana in 2026 isn't anonymity — it's privacy you can selectively reveal. Auditor keys in confidential transfers, Umbra's viewing-key hierarchy, OFAC-aware mixer design. Why 'compliant privacy' won, and how the disclosure mechanics actually work.
OpenWallet (OWS): a local, policy-gated wallet for the agent era
Give an AI agent a wallet and you've given it your private key. OWS — MoonPay's open standard — keeps keys local in ~/.ows, gates every signature through a policy engine, and exposes a CLI, SDKs, and an MCP server. One seed, nine chains including Solana. The model.
The Arcium Explorer: a block explorer for a network you can't see into
How do you build a block explorer for a privacy network? The Arcium Explorer surfaces the topology of Arcium's confidential computing on Solana — computations, clusters, Arx nodes, MXEs — while the actual inputs and outputs stay encrypted. The line it draws between observable and secret.
Quantum-proofing Solana: what you can do today, and the migration path
Quantum computers don't break hashes — they break elliptic curves. That single fact shapes Solana's entire post-quantum roadmap: PDAs are already safe, Winternitz one-time signatures ship today via Winterwallet, and Falcon-512 plus bigger transactions finish the job. A walk through the threat model and the practical moves, building on Blueshift's research.
How an AI agent actually pays: x402, MCP, and agent wallets on Solana
An agent that can call any paid API on the open internet sounds great until you ask: whose money, and what stops it from draining the wallet? This is the practical wiring — x402 inside the MCP tool loop, the @x402/svm client, and the Solana agent wallets (Coinbase, Crossmint, Privy, SendAI) that enforce spend caps and allowlists.
Build an x402 seller on Solana (and when to run your own facilitator)
Delegating to a facilitator is one line. But to ship a real x402 seller you need to understand the v2 middleware, the Solana 'exact' scheme down to the instruction order, how replay protection actually works (blockhash + memo nonce), and when it's worth running your own facilitator instead of Coinbase's or PayAI's.
The agentic payments landscape: x402 vs AP2, MPP, L402, and Solana Pay
Everyone's racing to be the payment layer for AI agents, and the names blur together: x402, AP2, MPP, L402. They're not all competitors — some are settlement rails, one is an authorization layer, one is for humans at a checkout. Here's the map, what each is actually for, and why Solana ends up at the center of the settlement story.
What x402 is actually for: six agentic-payment patterns on Solana
x402 is easy to explain and easy to over-apply. The useful question isn't 'how does it work' but 'what is it actually good for' — and the answer is six recognizable patterns, each with real Solana deployments (Pay.sh, Exa, Venice, Helius). Plus the cases where you should reach for an API key instead.
Qlaster: shared-memory streaming when your Solana services share a host
Most Solana streaming assumes the consumer is somewhere else on the network, so it serializes and ships bytes over gRPC. But a lot of infra — RPC sidecars, indexers, MEV bots — runs on the same host as the validator. Qlaster is a Rust system that fans account/tx updates over shared-memory rings instead of sockets: zero-copy, eventfd-driven, SCM_RIGHTS fd passing. A look at the design.
solana.new: an AI-native CLI from idea to raise
Most Solana scaffolds stop at 'here's a dApp template.' solana.new goes further — a Claude-powered CLI that takes you from 500+ vetted ideas through code generation, GTM copy, and a pitch deck, backed by curated catalogs of repos, skills, and MCPs. One curl command. What it actually installs.
web3.js 3.0: the classic API, rebuilt on Kit — Solana's TypeScript reunion
Solana's TypeScript ecosystem fractured: web3.js v1, then the Kit rewrite, then Gill and Kite wrappers — and choice paralysis. web3.js 3.0 is the convergence move: the API everyone already knows, rebuilt on Kit's modern internals. What it actually is, with the package facts the announcement leaves out.
Stables: a stablecoin payments API that treats Solana as a settlement rail
Moving USDC between a bank account and a Solana wallet means KYC, FX quotes, sanctions screening, and settlement plumbing nobody wants to build. Stables wraps all of it behind a REST API — customers, quotes, transfers, virtual accounts, webhooks — with Solana as one of ten settlement rails. A protocol-level look.
Alpenglow: Solana's new consensus, and the end of Proof of History
Alpenglow is the biggest change to Solana's core in its history: it retires Proof of History and TowerBFT for a new consensus — Votor for finality, Rotor for propagation — targeting ~150ms finality. SIMD-0326 passed governance with 98% yes. What it actually does, and what breaks.
ZK Compression: cheaper accounts on Solana (and why it's not cNFTs)
State compression gave Solana cheap NFTs. ZK Compression generalises the idea to arbitrary accounts and tokens — ~100× cheaper, secured by a constant-size validity proof verified on-chain. The catch is compute. A developer's-eye view, and the cNFT distinction everyone gets wrong.
Solana Actions & Blinks: transactions from a URL
A Blink is a URL that unfurls into a signable transaction; an Action is the HTTP API behind it. Two endpoints — GET for metadata, POST for a serialized tx — turn any link into a one-tap payment or mint. Clean spec, real security questions. The wire-level view.
DoubleZero: a dedicated fiber network under Solana's validators
Consensus isn't Solana's bottleneck — the public internet is. DoubleZero is a contributor-supplied fiber network with FPGA edge filtering and native multicast, purpose-built for validator block propagation. Mainnet-beta launched Oct 2025 with ~20%+ of staked SOL. What it is and who's behind it.
Token-2022 Confidential Transfers: encrypted balances, and the ZK proof saga
Token-2022 can hide how much you hold and move — encrypting balances with twisted ElGamal and proving correctness with zero-knowledge range proofs. It hides amounts, not parties. And in mid-2025 two proof-soundness bugs took the ZK ElGamal program offline. The mechanism, honestly.
Yellowstone gRPC: how real-time Solana data actually streams
If you've ever missed a websocket update or polled getProgramAccounts in a loop, this is the fix. Yellowstone gRPC taps Solana's Geyser interface and streams filtered account/tx/slot/block updates over HTTP/2 — lower latency, server-side filtering, real backpressure. The data layer indexers actually use.
The DAS API: one interface to read every Solana asset
Compressed NFTs don't have accounts, so getAccountInfo can't see them. The DAS API is how you read them — plus regular NFTs, Token-2022, and fungibles — from one standardized interface. The methods, why getAssetProof is essential for cNFT transfers, and the indexer dependency.
Metaplex Core: an NFT in one account
Token Metadata spreads an NFT across three-plus accounts. Metaplex Core puts the whole thing in one — ~0.0037 SOL to mint vs ~0.022, ~17k CU vs ~205k — with a modular plugin system for royalties, freezing, and on-chain data. The catch: a Core asset isn't an SPL token.
Restaking on Solana: Jito, Solayer, and Fragmetric compared
Restaking lets your staked SOL pull double duty: secure Solana, then secure other services for extra yield. Jito coined NCNs, Solayer split endogenous vs exogenous AVS, Fragmetric built it on Token-2022. The model, the three players, and the honest question — where's the real slashing risk and demand?
MEV on Solana: Jito bundles, swQoS, and the anti-sandwich fight
No public mempool, leader-based blocks, off-chain orderflow — MEV on Solana looks nothing like Ethereum. It runs through Jito's bundle auctions; sandwiching migrated to private validator deals after Jito killed its mempool in 2024. swQoS, and Paladin's economic counter-attack. The mechanics.
Drift Protocol: how Solana's biggest perp DEX is built
Drift runs perps, spot, lending, and prediction markets off one cross-margin account. Its liquidity is a three-layer hybrid: JIT auctions, a keeper-run decentralized order book, and a vAMM backstop. Powerful and capital-efficient — and the target of a >$270M exploit in April 2026. The architecture, honestly.
Solana Attestation Service: portable on-chain credentials
How does a DeFi app know a wallet passed KYC without seeing the passport? The Solana Attestation Service standardises that: issuers sign on-chain attestations that a wallet meets a credential; verifiers check them; raw data stays off-chain. Optionally tokenized via Token-2022. The model and its limits.
PayAI: the x402 facilitator on Solana
x402 needs someone to verify and settle payments — that's the facilitator. PayAI runs the biggest one after Coinbase, covers gas for both buyer and merchant, and lets a resource server stay completely chain-agnostic. Protocol view.
OTL: the Open Transaction Layer for compliant onchain transactions
Blockchains settle transactions; they don't coordinate who you're transacting with, whether they're compliant, or how to reconcile the off-chain context. OTL — backed by Fireblocks, Robinhood, MetaMask, Stripe's Privy and the Solana Foundation's consortium — is an open stack for exactly that. Protocol view.
ProofNetwork's MCP: docs-as-a-tool for building proof-backed Solana apps
ProofNetwork is a serverless JavaScript runtime where every execution is proof-backed. Its MCP server doesn't run contracts — it serves the documentation an agent needs to write them: four tools over Streamable HTTP, two skills, real VRF and key-storage APIs. A look at the docs-as-MCP pattern.
The Solana Vote Program: schema, instructions, and how to read it
Vote Program byte layout, the VoteInstruction enum, TowerSync serialization, lockout math, and JS code to read every field of a live vote account. Pure technical reference.
MetaDAO: how futarchy on Solana actually works (three programs, two markets, one TWAP)
Decisions by markets, not votes. MetaDAO's futarchy mints conditional-on-pass and conditional-on-fail tokens per proposal, runs a market for each, and finalises whichever TWAP is higher. Here's the on-chain architecture.
Generating Solana vanity addresses at 17 billion per second with caveman's `vanity`
Don't grind keypairs. Grind seeds. caveman's `vanity` tool generates Solana vanity addresses via CreateAccountWithSeed at GPU speed — here's why it's so much faster and what you give up.
ProgramWatch: the Solana program explorer that surfaces what Solscan won't
Every general explorer shows you transactions. ProgramWatch shows you the things you actually want to know about a program before you CPI into it — upgrade authority, freeze status, verified build, IDL availability.
The official Solana Explorer: open source, forkable, the reference decoder
Everyone uses explorer.solana.com. Fewer people know the whole thing is Apache-2.0 on GitHub, runs locally pointed at any cluster, and is what most branded chain explorers are forked from.
Stablecoins on Solana: mint registry, decimals, and Token-2022 extensions
USDC, USDT, PYUSD, USDG, USDY and friends — their actual mint addresses, decimals, token program, and the on-chain extensions each issuer wired up. The technical sheet you need before integrating any of them.
Crossmint on Solana: wallets, fiat checkout, and minting from one SDK
Embedded smart wallets, fiat checkout, REST minting, and agent wallets — one TypeScript SDK across 40+ chains, Solana first-class. Where it wins and where it doesn't.
Solana CPI: how one program calls another, the actual mechanics
CPI is how Solana programs compose. Account meta forwarding, invoke vs invoke_signed, signer seeds, the 4-deep call limit, and reading return data from the called program.
Solana PDAs: program-derived addresses, the actual math
PDA derivation, the bump search, off-curve check, invoke_signed semantics, and the canonical patterns for using PDAs as program-owned state.
Flash Trade: pool-to-peer perpetuals on Solana, the mechanism
No order book, no matching engine. Flash Trade prices perps off Pyth, executes against a shared liquidity pool (FLP), and LPs earn fees + the trader's net losses. The pool-to-peer model explained.
Phoenix: the crankless on-chain order book, and the perps extension
Phoenix proved a fully on-chain CLOB could work on Solana without a crank — fills settle atomically in the taker's transaction. The market/seat account model, the crankless design, and why it matters.
Solana's developer platform: the official on-ramp for new builders
solana.com/developers is the Solana Foundation's curated hub — docs, bootcamps, the Cookbook, payments primitives, and links into every meaningful learning path in the ecosystem. Here's how to actually use it.
Solana compute units: the actual cost table and how to budget
What a compute unit actually costs (per syscall, per opcode), the 200k default, the 1.4M per-tx cap, and how to set the limit + price right per instruction.
Solana transactions and limits: 1232 bytes, 64 signatures, 1.4M CUs
The four hard limits — size, signatures, compute, accounts — that bound every Solana transaction. Where each comes from, when you'll hit it, and how to work around it.
Solana RPC providers compared: methods, streaming, archival, and price
Five serious Solana RPC providers, compared on the technical axes that actually differ: enhanced methods, Geyser gRPC streaming, DAS API, archival depth, staked connections for landing, and pricing model.
From Wormhole to Frontier: the history of Solana hackathons and the rise of Colosseum
Solana's hackathons have produced more of the ecosystem's top protocols than any other on-ramp. Here's the full timeline — from the 2020 Wormhole hackathon to today's Colosseum-run Frontier — and why the hackathon → accelerator → venture model became Solana's strategic moat.
Blueshift: where Solana developers go to actually learn
Free, structured Solana learning with on-chain verified challenges, courses from beginner to sBPF assembly, and a research arm that goes deeper than anyone else outside the validator teams.
Privy vs Dynamic vs Magic vs Crossmint vs Reown vs Lazorkit: the embedded wallet showdown
Six serious players, six different bets. The full embedded-wallet comparison for Solana — multi-chain incumbents, stablecoin platforms, the Walletconnect rebrand, and the passkey-native challenger.
Testing Solana programs with LiteSVM: the workflow, Rust and TS
Beyond 'what is LiteSVM' — the actual testing workflow. Rust integration tests, the TypeScript bindings, setting arbitrary account state, warping the clock, and wiring it into CI for sub-second test runs.
Turbin3: the talent engine behind half of Solana's engineering
How Turbin3 has trained 2,000+ Solana engineers since 2022 — and why its alumni keep showing up at Jupiter, Helius, Metaplex, and most of the protocols you've heard of.
Superteam Talent: the recruiting layer the Solana ecosystem actually uses
A community-powered recruiting agency that connects engineers, designers, and operators with the Solana teams hiring them — without the noise of a traditional job board.
Solana derivation paths: BIP44, m/44'/501', and the Ledger gotcha
BIP39 → BIP44 with coin type 501 → ed25519. The canonical Solana path, the Ledger variant, hardened vs non-hardened, and why different wallets sometimes derive different addresses from the same seed phrase.
What is LiteSVM on Solana
A fast, lightweight library for testing Solana programs in Rust. Wraps the Sealevel VM directly — no validator, no async runtime, no RPC layer.
SPL Token vs Token-2022: program IDs, account layout, and what changed
Two program IDs, the same core schema, plus Token-2022's extension framework appended after the base mint. How to detect which you're dealing with and how the wire formats actually differ.
Mobile Wallet Adapter: how Solana dapps talk to wallets on a phone
MWA is the spec every Solana mobile wallet implements. Intent URI handshake, session-token capability model, sign-and-send flow, and how it differs from the desktop wallet-adapter pattern.
Token-2022 extensions: a field guide for builders
Token-2022 ships ~15 extensions that used to require custom programs. Here's what each one is for, what it costs, and how to combine them without painting yourself into a corner.
p-token: how Solana rewrote its most-called program (4,645 CU → 76)
SPL Token ate ~10% of every block. The Pinocchio rewrite cut a transfer from 4,645 CU to 76 — a ~98% reduction — shipped under the same program ID via SIMD-0266. The numbers, the rollout, and the one thing that breaks for indexers.
Solana staking: the Stake program, account states, and warmup math
Stake accounts, the warmup/cooldown math, the four states, and the actual instruction shapes for delegate, deactivate, split, merge, and withdraw. The technical reference.
Address Lookup Tables on Solana: when they earn back their cost
ALTs trade a one-time setup cost for ~31 bytes saved per address on every future transaction. Worth doing for hot programs; pointless for one-shots. Here's the actual math.
Solana validators: identity, vote, stake, and what running one actually requires
Identity key, vote account, delegated stake — three on-chain primitives plus the hardware to run them. The technical view of what a Solana validator actually is.
Solana priority fees in 2026: CU price, Jito tips, or both?
Three ways to pay for inclusion: CU price, Jito tips, both. Each works in different scenarios — here's the decision tree and the numbers behind it.
Squads: how Solana's standard multisig actually works on-chain
Squads V4 program architecture — Multisig accounts, vault PDAs, transaction proposals, approval and rejection thresholds, ephemeral signers. The technical view.
codama: how the modern Solana stack generates TypeScript clients
Anchor's TypeScript client is a runtime IDL interpreter. codama is a build-time code generator that emits tree-shakeable, type-safe instruction builders. The difference matters.
SNS: Solana Name Service, the registry program, and how .sol resolves
Bonfida's Name Service program, the PDA derivation from SHA-256 hash + class + parent, the NameRecordHeader structure, and the canonical resolution flow for a .sol address.
Anchor vs Pinocchio vs Steel: three Solana program frameworks, compared
Anchor optimises for developer experience. Pinocchio optimises for compute units. Steel sits in the middle. Bundle size, CU cost, and ergonomics — compared.
Pyth: the on-chain price layer, Push vs Pull, and the price account schema
Pyth's publisher network, the aggregated price account, the Push (Solana-native) vs Pull (cross-chain) models, EMA price, confidence intervals, and how to consume a feed safely.
@solana/kit vs @solana/web3.js vs gill: the JS client situation in 2026
Legacy web3.js is on borrowed time. @solana/kit is the official successor. gill is the ergonomic wrapper. Here's the actual difference and what to use when.
Switchboard: the customisable oracle, queues, jobs, and aggregators
Switchboard's per-feed customisability — write your own job definition, get any data source on-chain. Queues, oracles, aggregator schema, and the randomness primitive.
Firedancer and the Solana validator client landscape in 2026
Five Solana validator clients exist in 2026, three are in production. Here's what each one does, what's on mainnet, and why client diversity finally matters.
MagicBlock: ephemeral rollups for real-time Solana, 10ms blocks and all
Ephemeral rollups let a Solana app temporarily delegate accounts to a faster L2-like runtime — 10ms blocks, free transactions, committed back to mainnet on demand. The mechanism explained.
Jito Block Engine, demystified: bundles, MEV, and what tips actually pay for
Jito tips show up in every Solana arb, snipe, and high-priority transaction. The Block Engine is the auction underneath. Here's the mechanism in concrete terms.
Surfpool: mainnet-fork test validator with RPC cheatcodes
Drop-in alternative to solana-test-validator. Fork Mainnet state on demand, set any account or token balance via RPC cheatcodes, deploy via Infrastructure-as-Code, watch it in a real-time dashboard.
State compression and cNFTs on Solana: when 99% cost reduction actually happens
cNFTs let you mint a million NFTs for the price of one. The trade-off is your reads now go through an RPC indexer — here's when that breaks even.
Arcium: MPC for Solana — compute over encrypted data, on-chain
MPC done right — a network of compute nodes that jointly evaluate functions over inputs none of them can see. Used for dark pools, sealed-bid auctions, and any flow that needs on-chain privacy without ZK proofs.
Solana Pay: the underrated spec every wallet already implements
A URL scheme. That's it. Solana Pay lets you accept stablecoins or SOL via QR code or deeplink, with every wallet on the network already supporting it.
Umbra: a privacy layer for Solana — shielded balances and private transfers
ZK-shielded balances on Solana. Deposit transparent funds into a shielded pool, transfer between shielded addresses without revealing amounts or counterparties, withdraw back to transparent. The on-chain mechanism.
DePIN on Solana: what Helium, Hivemapper, Render, and Honey Frame actually do
Helium for wireless, Hivemapper for maps, Render for GPUs, Honey Frame for IoT — DePIN on Solana spans four real markets. What's actually running, beyond the marketing.
@solana/kit: the modern JS client, functional + tree-shakeable
Branded types, pipe-based composition, codecs for serialization, no classes, no defaults. Kit's a fundamental redesign — not a coat of paint on web3.js. The concrete shape.
Solana AI agents in 2026: agent wallets, MCP servers, and what's actually shipping
Most of the AI x Solana narrative is marketing. The actual primitives — agent wallets, Solana MCP, agent kits — are small, useful, and easy to ship today.
Privy: white-label wallet infrastructure, the technical view
Privy's TEE-and-sharding key model, the User / Treasury / Agent wallet products, the React provider pattern, server-side wallet operations, and how recovery actually works.
Sanctum: how Solana's liquid staking platform actually works
Sanctum unbundled LST issuance from LST liquidity. Anyone can launch one, the Infinity pool aggregates them all, and JitoSOL/mSOL/bSOL became interchangeable at fair value.
Kit-squared: @solana/kit in SvelteKit, no React needed
Kit ships no React adapters because it doesn't need them — every primitive is a plain function. The SvelteKit integration pattern: RPC and wallet as stores, lifecycle-managed subscriptions, end-to-end SSR-safe.
Polymarket on Solana: why a prediction market migrates, and what changes
Polymarket's expansion to Solana isn't strategy theatre — it's UX. Sub-second order matching needs sub-second confirmation, and Ethereum L2s still can't deliver it cheaply.
Solana Unity SDK: the C# client for game devs, with real wallet integration
C# bindings for Solana — RpcClient, Wallet, Transaction, SPL Token. WebGL + Android + iOS targets, in-game wallet adapter, and how to ship a Solana action without the player ever leaving the game.
Rust + Anchor + Quasar: the standard Solana program stack in 2026
Cargo init through deploy, with Anchor for program ergonomics and Quasar (or solana-test-validator) for fast integration tests. The opinionated stack new Solana program authors converge on.
x402: HTTP 402 reborn — internet-native payments, on Solana
The HTTP 402 Payment Required status code finally gets a real spec. Coinbase's x402 turns it into a one-round-trip API payment flow, settled in USDC on Solana (and other chains). Pure-protocol view.
