Solana Playground

Create Playground Wallet

If you're new to Solana Playground, the first step is to create your Playground Wallet. This wallet will allow you to interact with the Solana network right from your browser.

Step 1. Connect to Playground

Click the "Not connected" button at the bottom left of the screen.

Step 2. Create Your Wallet

You'll see an option to save your wallet's keypair. Optionally, save your wallet's keypair for backup and 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 definitions you may find helpful:

• wallet address: a public key that serves as your unique identity on the Solana blockchain. Just like an email address is used to receive emails, your wallet address is used to receive SOL.
• connection cluster: a network of Solana nodes (computers running Solana validator client). Devnet is the cluster for developer testing.

Get Devnet SOL

Before we start building, we first need some devnet SOL.

From a developer's perspective, SOL is required for two main use cases:

• To create accounts on the network where we store data or deploy programs
• To pay for transaction fees when we interact with the network

Below are two methods to fund your wallet with devnet SOL:

Option 1: Using the Playground Terminal

To fund your Playground wallet with devnet SOL. In the Playground terminal, run:

solana airdrop 5

Option 2: Using the Devnet Faucet

If the airdrop command doesn't work (due to rate limits or errors), you can use the Web Faucet.

• Enter your wallet address (found at the bottom of the Playground screen) and select an amount
• Click "Confirm Airdrop" to receive your devnet SOL

Create Anchor Project

First, open https://beta.solpg.io in a new browser tab.

• Click the "Create a new project" button on the left-side panel.

• Enter a project name, select Anchor as the framework, then click the "Create" button.

You'll see a new project created with the program code in the src/lib.rs file.

use anchor_lang::prelude::*;
 
// This is your program's public key and it will update
// automatically when you build the project.
declare_id!("11111111111111111111111111111111");
 
#[program]
mod hello_anchor {
    use super::*;
    pub fn initialize(ctx: Context<Initialize>, data: u64) -> Result<()> {
        ctx.accounts.new_account.data = data;
        msg!("Changed data to: {}!", data); // Message will show up in the tx logs
        Ok(())
    }
}
 
#[derive(Accounts)]
pub struct Initialize<'info> {
    // We must specify the space in order to initialize an account.
    // First 8 bytes are default account discriminator,
    // next 8 bytes come from NewAccount.data being type u64.
    // (u64 = 64 bits unsigned integer = 8 bytes)
    #[account(init, payer = signer, space = 8 + 8)]
    pub new_account: Account<'info, NewAccount>,
    #[account(mut)]
    pub signer: Signer<'info>,
    pub system_program: Program<'info, System>,
}
 
#[account]
pub struct NewAccount {
    data: u64
}

Build and Deploy Program

To build the program, simply run build in the terminal.

build

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

Once the program is built, run deploy in the terminal to deploy the program to the network (devnet by default). To deploy a program, SOL must be allocated to the on-chain account that stores the program.

Before deployment, ensure you have enough SOL. You can get devnet SOL by either running solana airdrop 5 in the Playground terminal or using the Web Faucet.

deploy

Alternatively, you can also use the Build and Deploy buttons on the left-side panel.

Once the program is deployed, you can now invoke its instructions.

Test Program

Included with the starter code is a test file found in tests/anchor.test.ts. This file demonstrates how to invoke the initialize instruction on the starter program from the client.

// No imports needed: web3, anchor, pg and more are globally available
 
describe("Test", () => {
  it("initialize", async () => {
    // Generate keypair for the new account
    const newAccountKp = new web3.Keypair();
 
    // Send transaction
    const data = new BN(42);
    const txHash = await pg.program.methods
      .initialize(data)
      .accounts({
        newAccount: newAccountKp.publicKey,
        signer: pg.wallet.publicKey,
        systemProgram: web3.SystemProgram.programId,
      })
      .signers([newAccountKp])
      .rpc();
    console.log(`Use 'solana confirm -v ${txHash}' to see the logs`);
 
    // Confirm transaction
    await pg.connection.confirmTransaction(txHash);
 
    // Fetch the created account
    const newAccount = await pg.program.account.newAccount.fetch(
      newAccountKp.publicKey,
    );
 
    console.log("On-chain data is:", newAccount.data.toString());
 
    // Check whether the data on-chain is equal to local 'data'
    assert(data.eq(newAccount.data));
  });
});

To run the test file once the program is deployed, run test in the terminal.

test

You should see an output indicating that the test passed successfully.

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

You can then view the transaction logs by running the solana confirm -v command and specifying the transaction hash (signature) from the test output:

solana confirm -v [TxHash]

For example:

solana confirm -v 3TewJtiUz1EgtT88pLJHvKFzqrzDNuHVi8CfD2mWmHEBAaMfC5NAaHdmr19qQYfTiBace6XUmADvR4Qrhe8gH5uc

Alternatively, you can view the transaction details on SolanaFM or Solana Explorer by searching for the transaction signature (hash).

Close Program

Lastly, the SOL allocated to the on-chain program can be fully recovered by closing the program.

You can close a program by running the following command and specifying the program address found in declare_id!():

solana program close [ProgramID]

For example:

solana program close 2VvQ11q8xrn5tkPNyeraRsPaATdiPx8weLAD8aD4dn2r

Congratulations! You've just built and deployed your first Solana program using the Anchor framework!