Ethereum habits break here: 100 challenges rewire you to accounts, Anchor, and program-owned addresses before you deploy for real.
The first Solana program most people write fails before their logic even runs. Solana has no contract storage: programs are stateless code, and every byte of data lives in a separate account the caller must pass in explicitly, with the right permissions attached. Miss one and the runtime rejects the transaction. This course rebuilds the model from the account layer up, then gets you productive in Rust with Anchor, the framework that turns pages of hand-written account checks into a few declarative constraints. You will derive program-owned addresses and sign with them, mint tokens through the Solana Program Library, compress a collection into a Merkle tree so a million items cost pennies, put an upgrade key behind a multisig, and reproduce real audit findings on purpose. Programs are written in Rust, clients in TypeScript, and everything runs on devnet so nothing costs real money. Five capstone projects are on offer: a governance-gated token, a compressed-NFT collection with an indexer, a staking program, a token-gated vault, and a minimal automated market maker. Submit any three to earn your certificate.
Built by Lakshya
We grant free access case-by-case — students, career-switchers, builders on a tight budget. Sign in to send us a note.
Sign in to applyFinished the tasks? Take the prompt to your AI and get tested on it. We copy the prompt and open the app — just paste it in.
Learn only the borrowing, error, and byte-layout rules real programs hit, so the compiler stops blocking a build you already understand.
Declarative constraints and a generated client interface replace a hundred lines of manual validation you would otherwise get wrong.
Derive an address from seeds and let the program itself sign for it: the one pattern behind every vault, escrow, and mint authority.
Both token programs already run on-chain, so launching a token is a matter of wiring accounts and picking extensions, not writing one.
A single upgrade key is a single point of failure; move it behind proposals, thresholds, and delays before anyone trusts your program.
One account per token stops being affordable at scale, so the data moves into a Merkle tree and only the root has to live on-chain.
There is no public mempool here, yet value still gets extracted; see how bundles land atomically and what it costs the person swapping.
Missing signer checks have drained real programs; reproduce each exploit yourself, then write the invariant test that would have caught it.
The free endpoint that worked in testing will rate-limit you on launch day; pick commitment levels, stream updates, and index what matters.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Launch a custom SPL token (or Token-2022) on devnet whose mint authority is a Squads multisig or your own governance program. The token must: have a fixed initial supply minted to a treasury, require a 2-of-3 multisig (or governance proposal) to mint more, and include at least one Token-2022 extension (metadata, permanent delegate, or transfer hooks). Submit: mint address, multisig/governance address, one transaction hash proving an additional mint required the multisig signature, and a README explaining the authority model.
Mint a collection of at least 1000 compressed NFTs (cNFTs) using Bubblegum on devnet. Set up a read path using either the Metaplex DAS API (Helius, Triton, SimpleHash) OR your own Geyser plugin / Postgres indexer. Submit: Merkle tree address, one cNFT mint proof, a screenshot of your indexer showing at least 3 cNFTs with their metadata resolved, and a write-up of the cost delta vs standard NFTs (should be ~1000× cheaper).
Build an Anchor program where users stake an SPL token and earn rewards proportional to stake × time. Include: a staking PDA per user, reward-rate configurable by admin, unstake with a cooldown period, and a slashing instruction the admin can invoke. Deliver: deployed program ID, TS client that stakes and claims, a test proving rewards match the theoretical formula within 0.1%, and a threat-model note on the admin powers.
Build a vault program that holds SOL and releases it only to holders of a specific SPL token. Use a PDA as the vault's authority. Demonstrate: depositing SOL into the vault (any user), the vault signing a withdrawal via CPI to the System program using PDA seeds, a check that the withdrawer holds ≥1 of the gating token (validated via CPI to the SPL Token program). Submit: program ID, gating token mint, one deposit and one gated-withdrawal transaction.
Build a minimal constant-product AMM (x * y = k) on Solana using Anchor. Support: pool creation for any token pair, add/remove liquidity (with LP tokens minted via CPI to the Token program), swap with configurable fee, and a safety check preventing zero-liquidity swaps. Deploy on devnet. Submit: program ID, one pool creation, two liquidity-add transactions, three swap transactions across price regimes, and a comparison of your fee math against Uniswap v2.
The Anchor framework's own docs. Focus on 'Account Types' and 'Constraints' chapters.