Anchor Framework on Solana: What It Is and How It Works

MetaLamp editorial team

16 February 2025

Read for 7 minutes

Developing smart contracts on the Solana blockchain can be a challenging task, especially for those used to the Ethereum and EVM ecosystems. The Anchor framework is designed to simplify the process—it's a tool for building programs in Rust with minimal code.
In this article, we'll break down what Anchor is, how it works, and what benefits it offers to dApp developers.

Security and Data Validation

Even the smallest mistake can lead to vulnerabilities and user fund losses. Anchor provides built-in tools for program security and data validation, minimizing risks and enabling the development of secure decentralized applications.

One of the key security mechanisms is macros, which define requirements for accounts involved in transactions and automatically verify their state.

The framework also restricts access to smart contract functions using account attributes. For example, the Signer type ensures that a transaction can only be executed after the user's digital signature. This is crucial for protecting data modification operations, as only account owners can perform specific actions.

For more complex validations, developers can use the require! macro, which allows manually setting conditions for transaction execution. If the condition isn’t met, an error is automatically returned, rejecting the transaction. This helps prevent incorrect operations and protects user data.

Additionally, Rust — the foundation of Anchor — has built-in safeguards against common issues like integer overflows and memory access errors.

Join our Telegram channel

Join us

In this space, we discuss the latest news, provide reviews, and share our insights on innovations and products in the world of web3.

Join us

Development

Next, we’ll provide a step-by-step guide to building your program. But first, you need to install dependencies and set up your environment. The framework runs on top of Rust and Solana CLI, so you’ll need to install:

Rust (via rustup)
Solana CLI (via the official installer)
Anchor (via Cargo)

When working with an Anchor project, you can fork the repository on GitHub to make modifications.

A program consists of three main parts:

#[program] — the core logic where function handlers are defined.
#[derive(Accounts)] — provides information about participating accounts.
#[account] — structures for storing data on the blockchain.

Example structure:

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

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        Ok(())
    }
}

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

#[account]
pub struct ExampleData {
    pub value: u64,
}
 

Let's create a new project using the command:

anchor init my_anchor_project

This command will create a basic project structure with the lib.rs file, which contains the core smart contract code. The program logic is structured using annotations, structs, and methods.

A basic program template might look like this:

 use anchor_lang::prelude::*;

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

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        msg!("Anchor program successfully initialized!");
        Ok(())
    }
}

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

 

In this code:

#[program] indicates the core logic of the program.
Context is used to manage accounts.
msg! is a macro that outputs a success message.

Now, the code needs to be compiled and deployed to the Solana network.

Creating a Journal Entry

To store journal entries, we can use PDA (Program Derived Addresses). Let's add a data structure (datum) for storing an entry:

 #[account]
pub struct JournalEntry {
    pub author: Pubkey,
    pub content: String,
}

 

This struct defines an entry with the author’s public key, the content, and a timestamp.

 pub fn create_entry(ctx: Context<CreateEntry>, content: String) -> Result<()> {
    let entry = &mut ctx.accounts.entry;
    entry.author = *ctx.accounts.author.key;
    entry.content = content;
    msg!("A new journal entry has been created: {}", entry.content);
    Ok(())
}

#[derive(Accounts)]
pub struct CreateEntry<'info> {
    #[account(init, payer = author, space = 8 + 32 + 256)]
    pub entry: Account<'info, JournalEntry>,
    #[account(mut)]
    pub author: Signer<'info>,
    pub system_program: Program<'info, System>,
}
 

Here:

The annotation #[account(init)] creates a new account (newaccount).
payer = author means the user covers the transaction cost.
space = 8 + 32 + 256 allocates memory for the entry.

Updating a Journal Entry

To update an existing entry, let's add a new handler:

 pub fn update_entry(ctx: Context<UpdateEntry>, new_content: String) -> Result<()> {
    let entry = &mut ctx.accounts.entry;
    require!(entry.author == *ctx.accounts.author.key, CustomError::Unauthorized);
    entry.content = new_content;
    msg!("Journal entry updated: {}", entry.content);
    Ok(())
}

#[derive(Accounts)]
pub struct UpdateEntry<'info> {
    #[account(mut, has_one = author)]
    pub entry: Account<'info, JournalEntry>,
    pub author: Signer<'info>,
}
 

Deleting a Journal Entry

To remove an entry, let's add a handler:

 pub fn delete_entry(ctx: Context<DeleteEntry>) -> Result<()> {
    require!(ctx.accounts.entry.author == *ctx.accounts.author.key, CustomError::Unauthorized);
    Ok(())
}

#[derive(Accounts)]
pub struct DeleteEntry<'info> {
    #[account(mut, close = author, has_one = author)]
    pub entry: Account<'info, JournalEntry>,
    #[account(mut)]
    pub author: Signer<'info>,
}
 

The annotation close = author ensures that after deletion, the remaining funds in the account are returned to the owner.

Creating and Deploying the Program

To deploy the program, run:

 anchor build
anchor deploy
 

Anchor will generate a program ID, which is needed for frontend interaction. When initializing the project, it's important to specify its name, for example, anchor init my_anchor_project.

Connecting the Program to the UI

To link the smart contract with the frontend, we use @project-serum/anchor in TypeScript.

Install dependencies:

 npm install @project-serum/anchor @solana/web3.js
Example Code to Call create_entry from the Browser
import * as anchor from "@project-serum/anchor";

const provider = anchor.AnchorProvider.local();
anchor.setProvider(provider);

const program = anchor.workspace.MyAnchorProject;

async function createEntry(content) {
    const entryAccount = anchor.web3.Keypair.generate();
    await program.rpc.createEntry(content, {
        accounts: {
            entry: entryAccount.publicKey,
            author: provider.wallet.publicKey,
            systemProgram: anchor.web3.SystemProgram.programId,
        },
        signers: [entryAccount],
    });
    console.log("Journal entry created:", entryAccount.publicKey.toString());
}
 

This function connects to the smart contract and sends a transaction to create an entry.

Client-Side Development

To interact with Solana programs from the frontend, you need JavaScript/TypeScript and @project-serum/anchor. This library simplifies calling program RPC functions.

Example of connecting to the program:

 import * as anchor from "@project-serum/anchor";

const provider = anchor.AnchorProvider.local(); // Local Provider for Testing
anchor.setProvider(provider);

const program = anchor.workspace.MyAnchorProject; // Accessing the Program

On-Chain Program Development

On-chain programs on Solana are written in Rust using the Anchor framework. They execute directly on the blockchain, which imposes certain constraints.

Each program has a fixed memory limit, so data must be optimized. The program's execution must always be deterministic. Using accounts and operations requires SOL payments. Anchor provides macros to simplify account and transaction management. For example, the #[account] macro defines a data structure stored on-chain.

Useful Tools for Development:

Solana CLI – Manage networks, accounts, and programs.
Anchor CLI – Simplifies program creation, testing, and deployment.
Localnet – A local network for testing without SOL costs.
Solana Explorer – A UI to view transactions, programs, and accounts.
Solana Devnet – A free network for deploying and testing programs.

Using an IDE with Rust support, such as Visual Studio Code with Rust plugins, can improve the development experience.

Application Development
on the Solana Blockchain

Learn more

We create scalable decentralized applications and smart contracts on Solana — one of the fastest blockchains for high-performance DeFi, NFT and Meme projects.

Learn more

Example Project

Let's look at a simple program that records and updates text.
Create a new project:

 anchor init example_project
cd example_project

In lib.rs, add the logic for storing data:
use anchor_lang::prelude::*;

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

    pub fn set_data(ctx: Context<SetData>, data: String) -> Result<()> {
        let account = &mut ctx.accounts.data_account;
        account.data = data;
        msg!("Data has been set!");
        Ok(())
    }
}

#[derive(Accounts)]
pub struct SetData<'info> {
    #[account(init, payer = user, space = 8 + 64)]
    pub data_account: Account<'info, DataAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[account]
pub struct DataAccount {
    pub data: String,
}

 

Deploy the Program:

 anchor build
anchor deploy

Here’s a simple counter program:

 use anchor_lang::prelude::*;

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

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.count = 0;
        msg!("Counter initialized!");
        Ok(())
    }

    pub fn increment(ctx: Context<Increment>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.count += 1;
        msg!("Counter incremented to {}", counter.count);
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = user, space = 8 + 8)]
    pub counter: Account<'info, Counter>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Increment<'info> {
    #[account(mut)]
    pub counter: Account<'info, Counter>,
}

#[account]
pub struct Counter {
    pub count: u64,
}
 

Key Takeaways

Anchor significantly simplifies program development, but like any tool, it requires a deep understanding.

First, despite automating many processes such as account management and data verification, developers must clearly understand how the blockchain processes transactions and interacts with accounts. Anchor programs are closely tied to Solana’s architecture: each object is a separate account with a defined structure and memory allocation.

When working with memory, it's important to consider strict data size limitations. Unlike traditional databases, storing information on-chain is costly and requires efficient resource usage. Anchor helps mitigate this issue by using lightweight data structures and macros for optimized memory management.

Additionally, Anchor provides a secure development model by automatically generating access control checks and transaction validation conditions. However, developers still need to ensure the security of their programs. For example, properly configuring write and execution permissions is crucial to prevent unauthorized data modifications.

Another important aspect is frontend integration via JavaScript and TypeScript. The @project-serum/anchor library simplifies interaction with programs by offering convenient functions for calling contract methods. Nevertheless, understanding RPC requests and key management is essential.

Testing is also critical. Anchor provides built-in tools for local testing, eliminating the need for deployment on a public network. This allows developers to catch errors faster and optimize code more efficiently.

The framework makes smart contract development on Solana significantly easier. Code can be written faster, more securely, and with fewer errors. Thanks to its intuitive API and built-in tools for managing accounts, it lowers the entry barrier for new developers. Building decentralized applications becomes more accessible, and the program code can be published on GitHub for public access and version control.

MetaLamp editorial team

16 February 2025