Comment développer un smart contract Solana avec Anchor en 2026

git clone https://github.com/coral-xyz/anchor.git && cd anchor && git checkout v0.31.0
cargo install --path ./cli --locked

sh -c "$(curl -sSfL https://release.solana.com/v2.0.0/install)"

solana-keygen new --outfile ~/.config/solana/id.json
solana config set --url https://api.devnet.solana.com

anchor init counter_program --typescript && cd counter_program

use anchor_lang::prelude::*;
use anchor_spl::token::{Token, TokenAccount, Mint};

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

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

    pub fn initialize(ctx: Context<Initialize>, init_value: u64) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        counter.count = init_value;
        counter.authority = ctx.accounts.user.key();
        Ok(())
    }

    pub fn increment(ctx: Context<Update>, amount: u64) -> Result<()> {
        let counter = &mut ctx.accounts.counter;
        require!(counter.authority == ctx.accounts.user.key(), ErrorCode::Unauthorized);
        counter.count += amount;
        emit!(CounterUpdated {
            counter: ctx.accounts.counter.key(),
            new_count: counter.count,
        });
        Ok(())
    }

    pub fn transfer_tokens_via_cpi(ctx: Context<TransferTokens>) -> Result<()> {
        let cpi_accounts = anchor_spl::token::Transfer {
            from: ctx.accounts.from.to_account_info(),
            to: ctx.accounts.to.to_account_info(),
            authority: ctx.accounts.authority.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        anchor_spl::token::transfer(cpi_ctx, 100)?;
        Ok(())
    }
}

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

#[derive(Accounts)]
pub struct Update<'info> {
    #[account(
        mut,
        seeds = [b"counter", user.key().as_ref()],
        bump,
        has_one = authority @ ErrorCode::Unauthorized
    )]
    pub counter: Account<'info, Counter>,
    pub user: Signer<'info>,
    pub authority: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct TransferTokens<'info> {
    #[account(mut)]
    pub from: Account<'info, TokenAccount>,
    #[account(mut)]
    pub to: Account<'info, TokenAccount>,
    pub authority: Signer<'info>,
    pub token_program: Program<'info, Token>,
}

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

#[event]
pub struct CounterUpdated {
    pub counter: Pubkey,
    pub new_count: u64,
}

#[error_code]
pub enum ErrorCode {
    #[msg("Unauthorized access")]
    Unauthorized,
}

import * as anchor from "@coral-xyz/anchor";
import { Program } from "@coral-xyz/anchor";
import { CounterProgram } from "../target/types/counter_program";
import { PublicKey, SystemProgram } from "@solana/web3.js";
import { TOKEN_PROGRAM_ID, getAssociatedTokenAddress } from "@coral-xyz/anchor/utils/token";

describe("counter_program", () => {
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);
  const program = anchor.workspace.CounterProgram as Program<CounterProgram>;
  const user = provider.wallet.publicKey;

  it("Initializes counter", async () => {
    const [counterPda] = PublicKey.findProgramAddressSync(
      [Buffer.from("counter"), user.toBuffer()],
      program.programId
    );

    await program.methods
      .initialize(new anchor.BN(42))
      .accounts({
        counter: counterPda,
        user: user,
        systemProgram: SystemProgram.programId,
      })
      .rpc();

    const counter = await program.account.counter.fetch(counterPda);
    console.log("Count:", counter.count.toString());
    expect(counter.count.toString()).toEqual("42");
  });

  it("Increments counter", async () => {
    const [counterPda] = PublicKey.findProgramAddressSync(
      [Buffer.from("counter"), user.toBuffer()],
      program.programId
    );

    await program.methods
      .increment(new anchor.BN(10))
      .accounts({
        counter: counterPda,
        user: user,
        authority: user,
      })
      .rpc();

    const counter = await program.account.counter.fetch(counterPda);
    expect(counter.count.toString()).toEqual("52");
  });

  it("CPI Token Transfer", async () => {
    // Assume mint/from/to setup in fixture
    const mint = anchor.web3.Keypair.generate().publicKey;
    const fromAta = await getAssociatedTokenAddress(mint, user);
    const toAta = await getAssociatedTokenAddress(mint, provider.wallet.publicKey);

    await program.methods
      .transferTokensViaCpi()
      .accounts({
        from: fromAta,
        to: toAta,
        authority: user,
        tokenProgram: TOKEN_PROGRAM_ID,
      })
      .rpc();
  });
});

anchor build
anchor test

solana airdrop 2 $(solana-keygen pubkey)
anchor deploy --provider.cluster devnet

anchor idl init --filepath target/idl/counter_program.json $(solana-keygen pubkey) devnet

import * as anchor from "@coral-xyz/anchor";
import { CounterProgram } from "../target/types/counter_program";
import { PublicKey } from "@solana/web3.js";

const provider = anchor.AnchorProvider.env();
anchor.setProvider(provider);
const program = anchor.workspace.CounterProgram as Program<CounterProgram>;
const user = provider.wallet.publicKey;

const [counterPda] = PublicKey.findProgramAddressSync(
  [Buffer.from("counter"), user.toBuffer()],
  program.programId
);

async function main() {
  const counter = await program.account.counter.fetch(counterPda);
  console.log("Current count:", counter.count.toString());

  await program.methods
    .increment(new anchor.BN(100))
    .accounts({ counter: counterPda, user, authority: user })
    .rpc();

  const updated = await program.account.counter.fetch(counterPda);
  console.log("Updated count:", updated.count.toString());
}

main().catch(console.error);