Get started

Solana config#

Inspect the current config with $solana config get:

$solana config get
Config File: /Users/test/.config/solana/cli/config.yml
RPC URL: https://api.mainnet-beta.solana.com 
WebSocket URL: wss://api.mainnet-beta.solana.com/ (computed)
Keypair Path: /Users/test/.config/solana/id.json 
Commitment: confirmed 

RPC URL and WebSocket URL identify the cluster the CLI targets. The default is mainnet-beta. To switch clusters, use either the long (--url) or short (-u<letter>) form:

Keypair Path points at the default wallet used to sign transactions and pay fees, located at ~/.config/solana/id.json. The next step generates a keypair at that location.

Create wallet#

The Solana CLI requires a keypair wallet funded with SOL to interact with the network. Generate one at the default keypair path:

$solana-keygen new
Generating a new keypair

For added security, enter a BIP39 passphrase

NOTE! This passphrase improves security of the recovery seed phrase NOT the
keypair file itself, which is stored as insecure plain text

BIP39 Passphrase (empty for none):

Wrote new keypair to /Users/test/.config/solana/id.json
===========================================================================
pubkey: 8dBTPrjnkXyuQK3KDt9wrZBfizEZijmmUQXVHpFbVwGT
===========================================================================
Save this seed phrase and your BIP39 passphrase to recover your new keypair:
cream bleak tortoise ocean nasty game gift forget fancy salon mimic amazing
===========================================================================

Print the public key of the wallet with $solana address:

$solana address
8dBTPrjnkXyuQK3KDt9wrZBfizEZijmmUQXVHpFbVwGT

Airdrop SOL#

Your wallet needs SOL to pay transaction fees and deployment costs. Point the CLI at devnet:

$solana config set -ud
Config File: /Users/test/.config/solana/cli/config.yml
RPC URL: https://api.devnet.solana.com 
WebSocket URL: wss://api.devnet.solana.com/ (computed)
Keypair Path: /Users/test/.config/solana/id.json 
Commitment: confirmed 

Then request an airdrop with $solana airdrop 2.

$solana airdrop 2
Requesting airdrop of 2 SOL
Error: airdrop request failed. This can happen when the rate limit is reached.

Check the wallet balance with $solana balance:

$solana balance
2 SOL

Run local validator#

The Solana CLI ships with a built-in test validator for local development.

In a separate terminal, start the validator with $solana-test-validator.

Initialize project#

Create a new Anchor project with $anchor init <project-name>.

This creates a directory named <project-name> and scaffolds a modular Rust program. Tests default to the LiteSVM crate. To choose a different test template (mollusk, mocha, jest, etc.), pass --test-template:

$anchor init <project-name> --test-template mollusk

Navigate into the new directory with $cd <project-name>.

Build program#

Compile the program with $anchor build. The compiled artifact is written to target/deploy/.

Deploy program#

Deploy the program to the cluster specified in Anchor.toml with $anchor deploy.

Test program#

Run the project’s test suite with $anchor test.

Create Playground wallet#

If you’re new to Solana Playground, the first step is to create your Playground wallet. This wallet lets you interact with the Solana network right from your browser.

Click the “Not connected” button at the bottom left of the screen.

You’ll see an option to save your wallet’s keypair. Optionally save it for backup, then click “Continue”.

You should now see your wallet’s address, SOL balance, and connected cluster (Devnet by default) at the bottom of the window.

Some useful terms:

Get Devnet SOL#

Before we start building, we need some devnet SOL. SOL is required to create accounts on the network and to pay transaction fees.

In the Playground terminal, run $solana airdrop 5. If the airdrop command doesn’t work (due to rate limits), use the Web Faucet. Enter your wallet address (found at the bottom of the Playground screen), select an amount, and click “Confirm Airdrop”.

Create Anchor project#

Open https://beta.solpg.io in a new browser tab. Click “Create a new project”, enter a project name, select Anchor as the framework, then click “Create”.

You’ll see a new project with the program code in src/lib.rs:

1
use anchor_lang::prelude::*;
2

3
// This is your program's public key and it will update
4
// automatically when you build the project.
5
declare_id!("11111111111111111111111111111111");
6

7
#[program]
8
mod hello_anchor {
9
    use super::*;
10
    pub fn initialize(ctx: Context<Initialize>, data: u64) -> Result<()> {
11
        ctx.accounts.new_account.data = data;
12
        msg!("Changed data to: {}!", data); // Message will show up in the tx logs
13
        Ok(())
14
    }
15
}
16

17
#[derive(Accounts)]
18
pub struct Initialize<'info> {
19
    // We must specify the space in order to initialize an account.
20
    // First 8 bytes are default account discriminator,
21
    // next 8 bytes come from NewAccount.data being type u64.
22
    // (u64 = 64 bits unsigned integer = 8 bytes)
23
    #[account(init, payer = signer, space = 8 + 8)]
24
    pub new_account: Account<'info, NewAccount>,
25
    #[account(mut)]
26
    pub signer: Signer<'info>,
27
    pub system_program: Program<'info, System>,
28
}
29

30
#[account]
31
pub struct NewAccount {
32
    data: u64
33
}

Build and deploy program#

To build the program, run $build in the terminal:

$build
Building...
Build successful. Completed in 1.46s.

Notice that the address in declare_id!() has been updated. This is your program’s on-chain address.

Once built, run $deploy to deploy to the network (devnet by default). Make sure you have enough SOL first:

$deploy
Deploying... This could take a while depending on the program size and network conditions.
Warning: 8 transactions not confirmed, retrying...
Deployment successful. Completed in 18s.

You can also use the Build and Deploy buttons on the left-side panel.

Test program#

The starter code includes a test file at tests/anchor.test.ts that shows how to invoke the initialize() instruction from the client:

1
// No imports needed: web3, anchor, pg and more are globally available
2

3
describe('Test', () => {
4
  it('initialize', async () => {
5
    // Generate keypair for the new account
6
    const newAccountKp = new web3.Keypair()
7

8
    // Send transaction
9
    const data = new BN(42)
10
    const txHash = await pg.program.methods
11
      .initialize(data)
12
      .accounts({
13
        newAccount: newAccountKp.publicKey,
14
        signer: pg.wallet.publicKey,
15
        systemProgram: web3.SystemProgram.programId,
16
      })
17
      .signers([newAccountKp])
18
      .rpc()
19
    console.log(`Use 'solana confirm -v ${txHash}' to see the logs`)
20

21
    // Confirm transaction
22
    await pg.connection.confirmTransaction(txHash)
23

24
    // Fetch the created account
25
    const newAccount = await pg.program.account.newAccount.fetch(newAccountKp.publicKey)
26

27
    console.log('On-chain data is:', newAccount.data.toString())
28

29
    // Check whether the data on-chain is equal to local 'data'
30
    assert(data.eq(newAccount.data))
31
  })
32
})

Run the tests with $test:

$test
Running tests...
  anchor.test.ts:
  Test
    Use 'solana confirm -v h6JV2E4HKiFMHLVQaFDRma9h8K3RBHKTb7vMiT8cLBsVQoyBnZmF6wD5cSrEG1ai6Bu7x7ibJakAyqXE45BJti' to see the logs
    On-chain data is: 42
    ✓ initialize (2139ms)
  1 passing (2s)

You can also click the Test button on the left-side panel.

To view the transaction logs, run $solana confirm -v with the transaction hash from the test output:

$solana confirm -v h6JV2E4HKiFMHLVQaFDRma9h8K3RBHKTb7vMiT8cLBsVQoyBnZmF6wD5cSrEG1ai6Bu7x7ibJakAyqXE45BJti
RPC URL: https://api.devnet.solana.com
Default Signer: Playground Wallet
Commitment: confirmed

Transaction executed in slot 457828860:
  Block Time: 2026-04-24T13:51:45-07:00
30 collapsed lines
  Version: legacy
  Recent Blockhash: FEfP1gMjVdNrLiHoxc67C2cXBsGF3cy9s8QPmEhjb7Q4
  Signature 0: h6JV2E4HKiFMHLVQaFDRma9h8K3RBHKTb7vMiT8cLBsVQoyBnZmF6wD5cSrEG1ai6Bu7x7ibJakAyqEXE45BJti
  Signature 1: 5TWWTnvJaiaooPR7zgACSUjxuZ6kz8eDnBjCd1AyVBMSWa9mvm3HedsN54Tu9iLJasbN4GpFcfSXqgrCri2cqRRc
  Account 0: srw- DY6arEvmJEfVXERsZ6LusRpjz5y5bqwQJRVcyE1zChBB (fee payer)
  Account 1: srw- 2vWvBBYP5PLczTuTm7nN7mhUEM45kxex9ASjXqrEh9Dh
  Account 2: -r-- 11111111111111111111111111111111
  Account 3: -r-x 3uCJdLdxY9fThNZ9U3oaBmhzxnEvZaRUiRYTJHZVxM4f
  Instruction 0
    Program:   3uCJdLdxY9fThNZ9U3oaBmhzxnEvZaRUiRYTJHZVxM4f (3)
    Account 0: 2vWvBBYP5PLczTuTm7nN7mhUEM45kxex9ASjXqrEh9Dh (1)
    Account 1: DY6arEvmJEfVXERsZ6LusRpjz5y5bqwQJRVcyE1zChBB (0)
    Account 2: 11111111111111111111111111111111 (2)
    Data: [175, 175, 109, 31, 13, 152, 155, 237, 42, 0, 0, 0, 0, 0, 0, 0]
  Status: Ok
    Fee: ◎0.00001
    Account 0 balance: ◎2.09821932 -> ◎2.09720708
    Account 1 balance: ◎0 -> ◎0.00100224
    Account 2 balance: ◎0.000000001
    Account 3 balance: ◎0.00139896
  Log Messages:
    Program 3uCJdLdxY9fThNZ9U3oaBmhzxnEvZaRUiRYTJHZVxM4f invoke [1]
    Program log: Instruction: Initialize
    Program 11111111111111111111111111111111 invoke [2]
    Program 11111111111111111111111111111111 success
    Program log: Changed data to: 42!
    Program 3uCJdLdxY9fThNZ9U3oaBmhzxnEvZaRUiRYTJHZVxM4f consumed 6266 of 200000 compute units
    Program 3uCJdLdxY9fThNZ9U3oaBmhzxnEvZaRUiRYTJHZVxM4f success

Finalized

Close program#

You can close the program to reclaim the SOL allocated to it. To close a program, run:

$solana program close <program-id>
Closed Program Id <program-id>, 2.89823448 SOL reclaimed

Create a new project#

To start a new project, use the $anchor init <project-name> (for our examples, we will use my-project for <project-name>). This creates a new directory with the specified name and scaffolds a default program and test file. By default, Anchor generates a modular program structure to promote better code organization and maintainability:

• programs/

  • my-project/

    • src/

      • instructions/Instruction handler implementations

        • initialize.rs
      • constants.rs Program constants
      • error.rs Custom error definitions
      • instructions.rs Instructions module root
      • lib.rs Main entry point
      • state.rs Account state module root

lib.rs is the program’s entry point. It declares each submodule and wires instruction handlers into the #[program] block. The declare_id!() value is your program’s on-chain address (by default, the public key of the keypair at /target/deploy/my_project-keypair.json).

1
pub mod constants;
2
pub mod error;
3
pub mod instructions;
4
pub mod state;
5

6
use anchor_lang::prelude::\*;
7

8
pub use constants::_; pub use instructions::_; pub use state::\*;
9

10
declare_id!("3ynNB373Q3VAzKp7m4x238po36hjAGFXFJB4ybN2iTyg");
11

12
#[program] pub mod my_project { use super::\*;
13

14
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
15
        initialize::handler(ctx)
16
    }
17

18
}

1
use anchor_lang::prelude::*;
2

3
#[derive(Accounts)]
4
pub struct Initialize {}
5

6
pub fn handler(ctx: Context<Initialize>) -> Result<()> {
7
    msg!("Greetings from: {:?}", ctx.program_id);
8
    Ok(())
9
}

Test file#

Anchor generates a test file alongside the program. TypeScript is the default. To get a Rust test instead, pass --test-template rust (Rust client) or --test-template mollusk (Mollusk).

1
import * as anchor from '@anchor-lang/core'
2
import { Program } from '@anchor-lang/core'
3
import { MyProject } from '../target/types/my_project'
4

5
describe('my-project', () => {
6
  anchor.setProvider(anchor.AnchorProvider.env())
7
  const program = anchor.workspace.MyProject as Program<MyProject>
8

9
  it('Is initialized!', async () => {
10
    const tx = await program.methods.initialize().rpc()
11
    console.log('Your transaction signature', tx)
12
  })
13
})

1
use std::str::FromStr;
2

3
use anchor_client::{
4
    solana_sdk::{
5
        commitment_config::CommitmentConfig, pubkey::Pubkey, signature::read_keypair_file,
6
    },
7
    Client, Cluster,
8
};
9

10
#[test]
11
fn test_initialize() {
12
    let program_id = "3ynNB373Q3VAzKp7m4x238po36hjAGFXFJB4ybN2iTyg";
13
    let anchor_wallet = std::env::var("ANCHOR_WALLET").unwrap();
14
    let payer = read_keypair_file(&anchor_wallet).unwrap();
15

16
    let client = Client::new_with_options(Cluster::Localnet, &payer, CommitmentConfig::confirmed());
17
    let program_id = Pubkey::from_str(program_id).unwrap();
18
    let program = client.program(program_id).unwrap();
19

20
    let tx = program
21
        .request()
22
        .accounts(my_program::accounts::Initialize {})
23
        .args(my_program::instruction::Initialize {})
24
        .send()
25
        .expect("");
26

27
    println!("Your transaction signature {}", tx);
28
}

Build the program#

Run $anchor build to compile the program. The compiled artifact is written to /target/deploy/my_project.so. This binary is the executable bytecode uploaded to the chain during deployment.

Test the program#

Run $anchor test to execute the test suite against a local cluster.

With the default Anchor.toml targeting localnet, this starts a local validator, builds and deploys the program, runs the tests in /tests, then shuts the validator down.

Deploy to Devnet#

By default, the Anchor.toml config file in an Anchor project specifies the localnet cluster. To deploy your program to devnet, change the cluster value to "Devnet":

1
[toolchain]
2

3
[features]
4
resolution = true
5
skip-lint = false
6

7
[programs.localnet]
8
my_program = "3ynNB373Q3VAzKp7m4x238po36hjAGFXFJB4ybN2iTyg"
9

10
[provider]
11
cluster = "Localnet"
12
cluster = "Devnet"
13
wallet = "~/.config/solana/id.json"
14

15
[scripts]
16
test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"

Run $anchor deploy to push the program to the cluster specified in Anchor.toml. The $anchor test command also respects this setting.

To deploy to mainnet, update the Anchor.toml file to specify the mainnet cluster:

[provider]
cluster = "Devnet"
cluster = "Mainnet"
wallet = "~/.config/solana/id.json"

Update the program#

Solana programs are updated in place by redeploying a new build to the same program ID. After making code changes, run $anchor build to produce an updated .so artifact, then $anchor deploy to upload it.

Close the program#

Closing a program reclaims the SOL allocated to its on-chain account. Run $solana program close <program-id> to retire it:

$solana program close <program-id> --bypass-warning

The program ID is permanently retired once closed. You cannot redeploy to the same address.