Anchor
⚓
Anchor is a framework for Solana's Sealevel runtime providing several convenient developer tools.
- Rust eDSL for writing Solana programs
- IDL specification
- TypeScript package for generating clients from IDL
- CLI and workspace management for developing complete applications
If you're familiar with developing in Ethereum's Solidity, Truffle, web3.js or Parity's Ink!, then the experience will be familiar. Although the DSL syntax and semantics are targeted at Solana, the high level flow of writing RPC request handlers, emitting an IDL, and generating clients from IDL is the same.
Getting Started
For a quickstart guide and in depth tutorials, see the guided documentation. To jump straight to examples, go here. For the latest Rust API documentation, see docs.rs.
Packages
| Package | Description | Version | Docs |
|---|---|---|---|
anchor-lang |
Rust primitives for writing programs on Solana |  |
 |
anchor-spl |
CPI clients for SPL programs on Solana |  |
 |
anchor-client |
Rust client for Anchor programs |  |
 |
@project-serum/anchor |
TypeScript client for Anchor programs |  |
 |
Note
- Anchor is in active development, so all APIs are subject to change.
- This code is unaudited. Use at your own risk.
Examples
Build stateful programs on Solana by defining a state struct with associated methods. Here's a classic counter example, where only the designated authority can increment the count.
#[program]
mod counter {
#[state]
pub struct Counter {
authority: Pubkey,
count: u64,
}
pub fn new(ctx: Context<Auth>) -> Result<Self> {
Ok(Self {
auth: *ctx.accounts.authority.key
})
}
pub fn increment(&mut self, ctx: Context<Auth>) -> Result<()> {
if &self.authority != ctx.accounts.authority.key {
return Err(ErrorCode::Unauthorized.into());
}
self.count += 1;
Ok(())
}
}
#[derive(Accounts)]
pub struct Auth<'info> {
#[account(signer)]
authority: AccountInfo<'info>,
}
#[error]
pub enum ErrorCode {
#[msg("You are not authorized to perform this action.")]
Unauthorized,
}
Additionally, one can utilize the full power of Solana's parallel execution model by keeping the program stateless and working with accounts directly. The above example can be rewritten as follows.
use anchor::prelude::*;
#[program]
mod counter {
use super::*;
pub fn initialize(ctx: Context<Initialize>, authority: Pubkey) -> Result<()> {
let counter = &mut ctx.accounts.counter;
counter.authority = authority;
counter.count = 0;
Ok(())
}
pub fn increment(ctx: Context<Increment>) -> Result<()> {
let counter = &mut ctx.accounts.counter;
counter += 1;
Ok(())
}
}
#[derive(Accounts)]
pub struct Initialize<'info> {
#[account(init)]
pub counter: ProgramAccount<'info, Counter>,
pub rent: Sysvar<'info, Rent>,
}
#[derive(Accounts)]
pub struct Increment<'info> {
#[account(mut, has_one = authority)]
pub counter: ProgramAccount<'info, Counter>,
#[account(signer)]
pub authority: AccountInfo<'info>,
}
#[account]
pub struct Counter {
pub authority: Pubkey,
pub count: u64,
}
#[error]
pub enum ErrorCode {
#[msg("You are not authorized to perform this action.")]
Unauthorized,
}
Due to the fact that account sizes on Solana are fixed, some combination of the above is often required. For example, one can store store global state associated with the entire program in the #[state] struct and local state assocated with each user in individual #[account] structs.
For more, see the examples directory.
License
Anchor is licensed under Apache 2.0.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Anchor by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.
6 Sep 30, 2022
3 Feb 25, 2024
165 Dec 18, 2022
6 Aug 13, 2022
29 Jun 13, 2023
3.2k Jan 4, 2023
207 Dec 19, 2022
18 Jun 18, 2022
22 May 11, 2022
5 Mar 10, 2022
157 Dec 8, 2022
1 Oct 25, 2021
4 Jun 24, 2022
6 Jan 30, 2022
51 Dec 6, 2022
35 Mar 1, 2022
40 Oct 30, 2022
5 Feb 23, 2022
35 Sep 22, 2022