Solana Hello World with Anchor: First Program Guide

# 1. Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# 2. Solana CLI
sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
export PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"

# 3. Anchor Version Manager
cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
avm install latest
avm use latest

# 4. Verify all tools
rustc --version
solana --version
anchor --version
node --version

anchor init counter
cd counter

counter/
├── Anchor.toml          # project config + cluster settings
├── Cargo.toml           # Rust workspace
├── package.json         # TypeScript deps
├── programs/
│   └── counter/
│       ├── Cargo.toml
│       └── src/
│           └── lib.rs   # your program lives here
├── tests/
│   └── counter.ts       # TypeScript integration tests
└── target/
    └── types/
        └── counter.ts   # auto-generated TypeScript types

use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

#[program]
pub mod counter {
    use super::*;

    /// Creates a new counter account, owned by the user.
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.authority = ctx.accounts.user.key();
        counter.count = 0;
        msg!("Counter initialized. Authority: {}", counter.authority);
        Ok(())
    }

    /// Increments the counter by 1.
    /// Only the authority can call this.
    pub fn increment(ctx: Context<Increment>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.count = counter.count
            .checked_add(1)
            .ok_or(CounterError::Overflow)?;
        msg!("Count is now: {}", counter.count);
        Ok(())
    }
}

/// Accounts needed for the initialize instruction.
#[derive(Accounts)]
pub struct Initialize<'info> {
    /// The counter account to create.
    #[account(
        init,
        payer = user,
        space = 8 + Counter::INIT_SPACE
    )]
    pub counter: Account<'info, Counter>,
    /// The wallet paying for account creation.
    #[account(mut)]
    pub user: Signer<'info>,
    /// Required to create accounts.
    pub system_program: Program<'info, System>,
}

/// Accounts needed for the increment instruction.
#[derive(Accounts)]
pub struct Increment<'info> {
    /// The counter to update. Must be mutable.
    #[account(
        mut,
        has_one = authority
    )]
    pub counter: Account<'info, Counter>,
    /// Must match the authority stored in the counter.
    pub authority: Signer<'info>,
}

/// On-chain state for a counter.
#[account]
#[derive(InitSpace)]
pub struct Counter {
    pub authority: Pubkey,  // 32 bytes
    pub count: u64,         //  8 bytes
}

#[error_code]
pub enum CounterError {
    #[msg("Counter overflow")]
    Overflow,
}

import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { Counter } from "../target/types/counter";
import { assert } from "chai";

describe("counter", () => {
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);

  const program = anchor.workspace.Counter as Program<Counter>;
  const counterKeypair = anchor.web3.Keypair.generate();

  it("initializes a counter at zero", async () => {
    await program.methods
      .initialize()
      .accounts({
        counter: counterKeypair.publicKey,
        user: provider.wallet.publicKey,
        systemProgram: anchor.web3.SystemProgram.programId,
      })
      .signers([counterKeypair])
      .rpc();

    const account = await program.account.counter.fetch(
      counterKeypair.publicKey
    );
    assert.equal(account.count.toNumber(), 0);
    assert.equal(
      account.authority.toBase58(),
      provider.wallet.publicKey.toBase58()
    );
  });

  it("increments the counter", async () => {
    await program.methods
      .increment()
      .accounts({
        counter: counterKeypair.publicKey,
        authority: provider.wallet.publicKey,
      })
      .rpc();

    const account = await program.account.counter.fetch(
      counterKeypair.publicKey
    );
    assert.equal(account.count.toNumber(), 1);
  });

  it("increments again", async () => {
    await program.methods
      .increment()
      .accounts({
        counter: counterKeypair.publicKey,
        authority: provider.wallet.publicKey,
      })
      .rpc();

    const account = await program.account.counter.fetch(
      counterKeypair.publicKey
    );
    assert.equal(account.count.toNumber(), 2);
  });
});

anchor test

# Generate a wallet if you do not have one
solana-keygen new

# Point Solana CLI at devnet
solana config set --url devnet

# Check your devnet address
solana address

# Airdrop 2 SOL for deployment fees
solana airdrop 2

# Build the program
anchor build

# Deploy to devnet
anchor deploy --provider.cluster devnet

# Check deployment
solana program show <YOUR_PROGRAM_ID>