three.ws

        p.max_pool = max_pool;        p.lock_ts = lock_ts;        p.void_after_ts = void_after_ts;        p.status = STATUS_OPEN;        p.winning_outcome = 0;        p.totals = [0; MAX_OUTCOMES];        p.total_staked = 0;        p.fee_paid = 0;        p.paid_out = 0;        p.bump = ctx.bumps.pool;        emit!(PoolCreated { pool: p.key(), pool_id, mint: p.mint, lock_ts, void_after_ts });        Ok(())    }     pub fn stake(ctx: Context<Stake>, outcome: u8, amount: u64) -> Result<()> {        require!(!ctx.accounts.config.paused, StakeError::Paused);        let now = Clock::get()?.unix_timestamp;        let pool = &mut ctx.accounts.pool;        require!(pool.status == STATUS_OPEN, StakeError::NotOpen);        require!(now < pool.lock_ts, StakeError::Locked);        require!(outcome < pool.outcome_count, StakeError::BadOutcome);        require!(amount >= pool.min_stake, StakeError::BelowMinimum);         let pos = &mut ctx.accounts.position;

1. Line 154 p.bump = ctx.bumps.pool;: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
2. Line 155 emit!(PoolCreated { pool: p.key(), pool_id, mint: p.mint, lock_ts, void_after_ts });: Emits an Anchor event that clients can parse from the logs.
3. Line 159 pub fn stake(ctx: Context<Stake>, outcome: u8, amount: u64) -> Result<()> {: Touches staking state: the amount locked and when it was locked.
4. Line 160 require!(!ctx.accounts.config.paused, StakeError::Paused);: An explicit validation that aborts the instruction with an error.
5. Line 161 let now = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.

    /// longer access-bearing.    pub fn revoke_skill_license(ctx: Context<RevokeSkillLicense>) -> Result<()> {        require!(            ctx.accounts.skill_license.revoked_at == 0,            SkillLicenseError::AlreadyRevoked        );         let marketplace_bump = ctx.accounts.marketplace.bump;        let signer_seeds: &[&[&[u8]]] = &[&[MARKETPLACE_SEED, &[marketplace_bump]]];         token::freeze_account(CpiContext::new_with_signer(            ctx.accounts.token_program.to_account_info(),            FreezeAccount {                account: ctx.accounts.owner_token_account.to_account_info(),                mint: ctx.accounts.nft_mint.to_account_info(),                authority: ctx.accounts.marketplace.to_account_info(),            },            signer_seeds,        ))?;         let now = Clock::get()?.unix_timestamp;        ctx.accounts.skill_license.revoked_at = now;         emit!(SkillLicenseRevoked {

1. Line 171 require!(: An explicit validation that aborts the instruction with an error.
2. Line 176 let marketplace_bump = ctx.accounts.marketplace.bump;: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
3. Line 179 token::freeze_account(CpiContext::new_with_signer(: Makes a CPI signed by a PDA. The signer seeds prove the program controls that address.
4. Line 189 let now = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.
5. Line 192 emit!(SkillLicenseRevoked {: Emits an Anchor event that clients can parse from the logs.

        if let Some(o) = open {            door.open = o;        }        Ok(())    }     /// Pay the door's price into escrow and record one knock.    ///    /// `nonce` lets one sender knock the same door repeatedly; `message_hash`    /// is the SHA-256 of the message body, which stays off-chain.    pub fn knock(ctx: Context<Knock>, nonce: u64, message_hash: [u8; 32]) -> Result<()> {        let door = &ctx.accounts.door;        require!(door.open, KnockError::DoorClosed);        require_keys_eq!(door.mint, ctx.accounts.mint.key(), KnockError::WrongMint);         let price = door.price;        let now = Clock::get()?.unix_timestamp;        let expires_at = now            .checked_add(door.reply_window)            .ok_or(KnockError::MathOverflow)?;         token_interface::transfer_checked(            CpiContext::new(                ctx.accounts.token_program.to_account_info(),

1. Line 181 require!(door.open, KnockError::DoorClosed);: An explicit validation that aborts the instruction with an error.
2. Line 185 let now = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.
3. Line 187 .checked_add(door.reply_window): Uses checked arithmetic so overflow fails instead of wrapping.
4. Line 190 token_interface::transfer_checked(: A checked token transfer, which also verifies the mint and decimals.
5. Line 191 CpiContext::new(: Makes a cross-program invocation into another program.

        );         emit!(SkillInvoked {            invoker_agent,            target_agent,            invoker_authority: ctx.accounts.invoker_authority.key(),            skill_name,            parameters,            timestamp: Clock::get()?.unix_timestamp,        });         Ok(())    }} #[derive(Accounts)]#[instruction(skill_name: String, parameters: String)]pub struct InvokeSkill<'info> {    /// The invoking agent's program-derived identity. Constrained to the PDA    /// for `invoker_authority`, binding the on-chain agent to the signer.    /// CHECK: validated by the `seeds`/`bump` PDA constraint against this    /// program; never read or written, only its key is recorded.    #[account(        seeds = [AGENT_SEED, invoker_authority.key().as_ref()],

1. Line 63 emit!(SkillInvoked {: Emits an Anchor event that clients can parse from the logs.
2. Line 69 timestamp: Clock::get()?.unix_timestamp,: Reads on-chain time from the Clock sysvar.
3. Line 81 /// CHECK: validated by the `seeds`/`bump` PDA constraint against this: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
4. Line 84 seeds = [AGENT_SEED, invoker_authority.key().as_ref()],: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.