Course Catalog
Explore our courses and start building on Solana
Building Your First Solana Program
You arrive holding `vault_core.rs` — a `VaultState` and checked `deposit`/`withdraw` that compile, with no `#[program]` and no `#[derive(Accounts)]`. This course adds exactly that. You wrap your own Rust core in Anchor 1.x, create a per-user vault PDA with the space arithmetic derived rather than copied, and move real lamports: deposit through a System Program CPI, withdraw by debiting the program-owned vault directly above an enforced rent floor — and you learn why signer seeds are not the answer there. Then you write the account constraints that stop three named attacks, read the LiteSVM test that would catch what compiling cannot, deploy from a browser tab, publish the IDL on-chain, and call your own live program. Nothing is installed locally. You finish with a devnet program id, a fetchable IDL, and a build write-up.
Full-Stack Solana: Publish the SDK, Ship the dApp
You arrive holding a deployed vault program — a devnet program id and an Anchor 1.x IDL from Course 3. This course turns that program into two things a bounty reviewer will pay for: a published npm client anyone can install, and a deployed dApp that consumes it. You generate a typed Kit client from your own IDL with Codama, wrap it in the ergonomic API a stranger would actually import, write a README and a semver policy, and publish to npm from CI with build provenance. Then you build the app — connect a Wallet Standard wallet with no wallet-adapter, choose the right signer for what each wallet advertises, and send your first real devnet deposit from a public URL using the package you just published. You finish by making it correct, cheap and honest: a simulated and tightly-sized compute budget, a network-priced priority fee, and a UI driven by real confirmation commitment and decoded program errors. TypeScript and the browser only — nothing is installed locally. Version stamp — kit 7.0.0, @codama/renderers-js 2.3.0, checked 2026-07-27.
Getting Paid: Stablecoin & Agentic Payments
Put a price on an app that earns nothing. If you came through Course 4 that app is the vault you deployed and published a client for; if you are starting here, this is the segment's entry point and a frozen reference deployment stands in for it. Open a Subscription Authority and a Recurring Delegation so the app has a real paid tier, meter a route with an x402 v2 challenge, and give an autonomous agent a wallet that can say no — an on-chain spend cap instead of an unlimited keypair. TypeScript only, no Rust and no local toolchain. You finish by publishing a version-pinned deep dive and submitting one live Superteam Earn listing. Scope is what BCB Resolution 561 leaves open to Brazilian builders from 2026-10-01, domestic merchant acceptance, contractor payouts, subscriptions and agent budgets.
Rust for Program Developers
You can read a Solana account's bytes. You cannot yet write the struct those bytes came from. You finish this course holding `vault_core.rs` — a `VaultState` with `owner`, `balance` and `bump`, `deposit` and `withdraw` built on `checked_add`/`checked_sub` so a `u64` can never silently wrap, a `VaultError` enum with four named variants, and not one `unwrap()` — compiled green against the real Anchor 1.x toolchain on our build server. Nothing is installed locally — no rustup, no cargo, no `.so` upload. Ownership, borrowing and lifetimes are taught here rather than deferred, because `Account<'info, Vault>` is unreadable without them. Your file deliberately carries no `#[program]` and no `#[derive(Accounts)]` — that omission is the handoff, and Course 3 is what wraps around it.
Solana for Web Devs
You already write JavaScript or TypeScript. That is the whole prerequisite — no blockchain, no cryptography, no Rust, nothing installed. This course runs entirely in your browser against a real, frozen program on Solana's devnet. You start by reading its live vault account in an explorer, then decode its 49 raw bytes by hand — discriminator, owner, balance, bump — then reproduce its address from seeds, so an on-chain account stops being a mystery and becomes a byte layout you own. Then you sign: transaction anatomy with the exact fee arithmetic, a funded devnet wallet of your own, and a real deposit into the vault, confirmed on-chain with the signature to prove it. You finish by assembling everything into a working account inspector — paste any devnet address, get type, SOL, owner, rent-exemption, and decoded vault fields with every failure path handled. Everything is taught against `@solana/kit` 7.0.0, the current stack; one lesson maps it against the legacy web3.js v1 code you will still meet in the wild, with dates and download counts, so you can read old codebases without writing like them. Version stamp — kit 7.0.0, devnet, authored 2026-07-28.