What You Built

Version stamp — checked 2026-07-26. anchor-lang 1.1.2 · borsh 1.8.0 (resolved) · edition 2021 · Agave ≥ 3.1.10. No new code in this lesson; every claim below was compiled against that toolchain on that date.

Open your file from the last exercise. Not the reference below — yours. Read it once, top to bottom, before you read anything else on this page.

Here is the reference version, so you can check yours item for item:

use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

pub mod vault {
    use super::*;

    #[account]
    #[derive(InitSpace)]
    pub struct VaultState {
        pub owner: Pubkey,
        pub balance: u64,
        pub bump: u8,
    }

    #[error_code]
    pub enum VaultError {
        #[msg("Deposit would overflow the vault balance")]
        Overflow,
        #[msg("Withdrawal is larger than the vault balance")]
        InsufficientFunds,
        #[msg("Amount must be greater than zero")]
        ZeroAmount,
        #[msg("Signer is not the vault owner")]
        NotOwner,
    }

    impl VaultState {
        pub fn deposit(&mut self, amount: u64) -> Result<()> {
            require!(amount > 0, VaultError::ZeroAmount);
            self.balance = self
                .balance
                .checked_add(amount)
                .ok_or(VaultError::Overflow)?;
            Ok(())
        }

        pub fn withdraw(&mut self, amount: u64) -> Result<()> {
            require!(amount > 0, VaultError::ZeroAmount);
            self.balance = self
                .balance
                .checked_sub(amount)
                .ok_or(VaultError::InsufficientFunds)?;
            Ok(())
        }
    }
}

pub use vault::{VaultError, VaultState};

Forty-odd lines. Thirteen lessons. Every line came from somewhere specific, and being able to say where is the difference between having finished a course and being able to write the next file without one.

Line by line

Three absences, which are also the point

.clone() appears zero times. Lesson 5 was explicit that cloning is a legitimate escape hatch and not a moral failing. It is also true that in a &mut self method you never reach for it, because you never moved anything: you borrowed the account, wrote through the borrow, and gave it back.

unwrap() appears zero times. Every tutorial you will read on the way to your first real program uses it. In a program, a panic is an aborted instruction with no code and no message — the caller learns that something failed and nothing else. Your file returns 6001 with the string "Withdrawal is larger than the vault balance". That difference is the whole of lessons 4, 11 and 12.

Lifetimes appear zero times, and lesson 8 was not wasted on you. VaultState owns all three of its fields — a Pubkey, a u64 and a u8 are all owned values — so nothing in the struct borrows and there is no lifetime to name. What lesson 8 bought you is the next file: Account<'info, VaultState> in Course 3 is a borrowed view over these bytes, and 'info is the same annotation you wrote by hand on discriminator(data: &'a [u8]) -> Option<&'a [u8]>. Graduates who skip lifetimes read Account<'info, Vault> as noise for years. Question 6 below is that payoff, asked before you meet it.

Copy the file out. Now.

Say this plainly, because the platform does not: no block type on this platform persists your source file. The build server graded a submission; it did not keep a copy you can come back to. Select everything in the editor, save it locally as vault_core.rs, and put it somewhere you will find it next week.

If you lose it, Course 3's first lesson ships a known-good reference copy — the file above — so nothing dead-ends. But it will be a vault core, not yours, and the first thing Course 3 does is replace that placeholder in declare_id! with the program id of your own deployment.

What Course 3 adds, and why none of it is in your file

Your file has no #[program] module and no #[derive(Accounts)] struct. Read it cold and it looks like a program someone abandoned two-thirds of the way in. It is not. It is the two-thirds you can check by reading, deliberately separated from the third you cannot.

One currency note for when you start reading Course 3's material against the rest of the internet: CpiContext::new(System::id(), …) is the current shape. Every CPI tutorial written before Anchor 1.0 passes an account info instead — CpiContext::new(ctx.accounts.system_program.to_account_info(), …) — and it does not compile against the toolchain you have been building on. It is the single most common stale snippet in Solana material, and now you know why your copy-paste failed.

Why the split is the right shape, not a teaching convenience

Look at what your file does not depend on: no accounts, no signers, no clock, no CPI, no runtime of any kind. That is what makes it the part a reviewer reads first and the part a test can exercise in microseconds. Real audit findings cluster at the seam between the two halves — a handler that forgets to compare vault.owner to the signer, a constraint that validates the wrong account — and you cannot see a seam until the two sides of it are separate things.

It also means Course 3 is enterable on its own. Anyone arriving without this course gets the reference vault_core.rs, because a course whose first lesson requires a file you do not have is a dead end, not a prerequisite. You are arriving with your own version, which is a better place to start from.

What you can say you can do

Not "you can now write Solana programs" — you cannot yet, and one more course is why. What you can say is narrower and true: you can model on-chain state in Rust, make its invariants unbreakable by construction, and return named errors instead of panicking. That is the part of program development that no framework does for you.