Фреймворк Anchor на Solana: что такое и как работает

#[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,
}

anchor init my_anchor_project

use anchor_lang::prelude::*;

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

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        msg!("Программа Anchor успешно инициализирована!");
        Ok(())
    }
}

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

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

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!("Создана новая запись в журнале: {}", 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>,
}

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!("Запись обновлена: {}", entry.content);
    Ok(())
}

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

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>,
}

anchor build
anchor deploy

npm install @project-serum/anchor @solana/web3.js

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("Запись создана:", entryAccount.publicKey.toString());
}

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

const provider = anchor.AnchorProvider.local(); // Локальный провайдер для тестов
anchor.setProvider(provider);

const program = anchor.workspace.MyAnchorProject; // Доступ к программе

anchor init example_project
cd example_project

В lib.rs добавьте логику для записи данных:
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!("Данные установлены!");
        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,
}

anchor build
anchor deploy

А это — пример программы-счетчика:

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!("Счетчик инициализирован!");
        Ok(())
    }

    pub fn increment(ctx: Context<Increment>) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.count += 1;
        msg!("Счетчик увеличен до {}", 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,
}