BumpTrade

    pub operator: Signer<'info>,    #[account(seeds = [CONFIG_SEED], bump = config.bump)]    pub config: Account<'info, Config>,    #[account(address = config.mint)]    pub mint: Account<'info, Mint>,    #[account(init, payer = operator, space = 8 + Match::INIT_SPACE, seeds = [MATCH_SEED, match_id.as_ref()], bump)]    pub match_account: Account<'info, Match>,    #[account(        init,        payer = operator,        seeds = [VAULT_SEED, match_id.as_ref()],        bump,        token::mint = mint,        token::authority = match_account,    )]    pub vault: Account<'info, TokenAccount>,    pub token_program: Program<'info, Token>,    pub system_program: Program<'info, System>,} pub fn handler(ctx: Context<OpenMatch>, match_id: [u8; 32], max_players: u8, join_deadline: i64) -> Result<()> {    let config = &ctx.accounts.config;    require!(!config.paused, BumpError::Paused);    let now = Clock::get()?.unix_timestamp;

1. Line 13 pub operator: Signer<'info>,: Requires this account to have signed the transaction.
2. Line 14 #[account(seeds = [CONFIG_SEED], bump = config.bump)]: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
3. Line 14 #[account(seeds = [CONFIG_SEED], bump = config.bump)]: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
4. Line 18 #[account(init, payer = operator, space = 8 + Match::INIT_SPACE, seeds = [MATCH_SEED, matc: Creates and pays for a new account. Space and payer must be specified.
5. Line 35 require!(!config.paused, BumpError::Paused);: An explicit validation that aborts the instruction with an error.
6. Line 36 let now = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.

use anchor_lang::prelude::*; use crate::constants::*;use crate::error::BumpError;use crate::events::MatchStarted;use crate::state::{Config, Match}; #[derive(Accounts)]#[instruction(match_id: [u8; 32])]pub struct StartMatch<'info> {    #[account(constraint = operator.key() == config.operator @ BumpError::Unauthorized)]    pub operator: Signer<'info>,    #[account(seeds = [CONFIG_SEED], bump = config.bump)]    pub config: Account<'info, Config>,    #[account(mut, seeds = [MATCH_SEED, match_id.as_ref()], bump = match_account.bump)]    pub match_account: Account<'info, Match>,} pub fn handler(ctx: Context<StartMatch>, match_id: [u8; 32]) -> Result<()> {    let m = &mut ctx.accounts.match_account;    require!(m.status == STATUS_OPEN, BumpError::BadStatus);    require!(m.player_count >= 2, BumpError::NotEnoughPlayers);    m.status = STATUS_STARTED;    emit!(MatchStarted { match_id, settle_deadline: m.settle_deadline });

1. Line 12 pub operator: Signer<'info>,: Requires this account to have signed the transaction.
2. Line 13 #[account(seeds = [CONFIG_SEED], bump = config.bump)]: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
3. Line 13 #[account(seeds = [CONFIG_SEED], bump = config.bump)]: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
4. Line 21 require!(m.status == STATUS_OPEN, BumpError::BadStatus);: An explicit validation that aborts the instruction with an error.
5. Line 24 emit!(MatchStarted { match_id, settle_deadline: m.settle_deadline });: Emits an Anchor event that clients can parse from the logs.

    require!(!ctx.accounts.config.paused, BumpError::Paused);    let now = Clock::get()?.unix_timestamp;    let player = ctx.accounts.player.key();    let m = &mut ctx.accounts.match_account;    require!(m.status == STATUS_OPEN, BumpError::MatchNotOpen);    require!(now <= m.join_deadline, BumpError::JoinClosed);    require!(m.player_count < m.max_players, BumpError::MatchFull);    require!(m.seat_of(&player).is_none(), BumpError::AlreadyJoined);    require!(vehicle_id < VEHICLE_COUNT, BumpError::BadVehicle);     let seat = m.player_count as usize;    m.players[seat] = player;    m.session_keys[seat] = session_key;    m.vehicles[seat] = vehicle_id;    m.player_count += 1;    let stake = m.stake;     token::transfer(        CpiContext::new(            ctx.accounts.token_program.key(),            Transfer {                from: ctx.accounts.player_token.to_account_info(),                to: ctx.accounts.vault.to_account_info(),                authority: ctx.accounts.player.to_account_info(),

1. Line 25 require!(!ctx.accounts.config.paused, BumpError::Paused);: An explicit validation that aborts the instruction with an error.
2. Line 26 let now = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.
3. Line 40 let stake = m.stake;: Touches staking state: the amount locked and when it was locked.
4. Line 42 token::transfer(: An SPL token transfer through the Token Program.
5. Line 43 CpiContext::new(: Makes a cross-program invocation into another program.

    let bump = [match_bump];    let seeds: &[&[u8]] = &[MATCH_SEED, match_id.as_ref(), &bump];    token::transfer(        CpiContext::new_with_signer(            Token::id(),            Transfer { from: vault, to: destination, authority: match_account },            &[seeds],        ),        amount,    )} pub fn seat_token_account(info: &AccountInfo, owner: &Pubkey, mint: &Pubkey) -> Result<()> {    require!(info.is_writable && info.owner == &Token::id(), BumpError::BadRemainingAccounts);    let data = info.try_borrow_data()?;    let account = TokenAccount::try_deserialize(&mut &data[..]).map_err(|_| error!(BumpError::BadRemainingAccounts))?;    require_keys_eq!(account.owner, *owner, BumpError::BadRemainingAccounts);    require_keys_eq!(account.mint, *mint, BumpError::BadRemainingAccounts);    Ok(())}

1. Line 37 let bump = [match_bump];: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
2. Line 39 token::transfer(: An SPL token transfer through the Token Program.
3. Line 40 CpiContext::new_with_signer(: Makes a CPI signed by a PDA. The signer seeds prove the program controls that address.
4. Line 50 require!(info.is_writable && info.owner == &Token::id(), BumpError::BadRemainingAccounts);: An explicit validation that aborts the instruction with an error.