accel-AgentAuth

        token_program: s.in_token_program,        from: s.in_account,        mint: s.in_mint,        to: s.in_vault,        authority: s.payer,        amount: pull,        decimals: s.in_decimals,    }    .invoke_signed(&[])?;     // 2. pay the output from the output vault, authority = pool PDA.    let destination = if s.pool.mode == Mode::RedirectOutput {        s.in_account    } else {        s.out_account    };    let bump = [POOL_AUTHORITY_BUMP];    let seeds = [Seed::from(POOL_AUTHORITY_SEED), Seed::from(&bump)];    TransferChecked {        token_program: s.out_token_program,        from: s.out_vault,        mint: s.out_mint,        to: destination,        authority: s.authority,

1. Line 117 .invoke_signed(&[])?;: Makes a CPI signed by a PDA. The signer seeds prove the program controls that address.
2. Line 125 let bump = [POOL_AUTHORITY_BUMP];: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
3. Line 126 let seeds = [Seed::from(POOL_AUTHORITY_SEED), Seed::from(&bump)];: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
4. Line 127 TransferChecked {: A checked token transfer, which also verifies the mint and decimals.

    };    if !owner.is_signer() {        return Err(MandateError::InvalidSigner.into());    }    if owner.key() == agent.key() {        return Err(MandateError::InvalidAgent.into());    }    let (expiry, rest) = take_u64(data)?;    expect_end(rest)?;    let expiry = expiry as i64;     let (expected, bump) = find_program_address(        &[MANDATE_SEED, owner.key().as_ref(), agent.key().as_ref()],        program_id,    );    if mandate_account.key() != &expected {        return Err(MandateError::InvalidAccountType.into());    }    if expiry <= Clock::get()?.unix_timestamp {        return Err(MandateError::InvalidExpiry.into());    }    if !mandate_account.is_writable() {        return Err(ProgramError::InvalidAccountData);    }

1. Line 48 let (expected, bump) = find_program_address(: Derives a PDA from seeds and the program ID and returns the address with its canonical bump.
2. Line 48 let (expected, bump) = find_program_address(: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
3. Line 55 if expiry <= Clock::get()?.unix_timestamp {: Reads on-chain time from the Clock sysvar.

        AccountMeta::readonly(owner.key()),        AccountMeta::readonly_signer(agent.key()),    ];    let ix = Instruction {        program_id: &AGENT_AUTH_ID,        accounts: &metas,        data: &data,    };    invoke_signed_with_bounds::<3>(&ix, &[mandate, owner, agent], &[])} /// Accounts of the `TransferChecked` CPI.pub struct TransferChecked<'a> {    /// SPL Token or Token-2022 program.    pub token_program: &'a AccountInfo,    /// Source token account (writable).    pub source: &'a AccountInfo,    /// Mint (read-only).    pub mint: &'a AccountInfo,    /// Destination token account (writable).    pub destination: &'a AccountInfo,    /// Authority PDA, the SPL delegate; signs with the stored bump.    pub authority: &'a AccountInfo,    /// Mandate key, the second seed of the authority PDA.

1. Line 69 invoke_signed_with_bounds::<3>(&ix, &[mandate, owner, agent], &[]): Makes a CPI signed by a PDA. The signer seeds prove the program controls that address.
2. Line 72 /// Accounts of the `TransferChecked` CPI.: A checked token transfer, which also verifies the mint and decimals.
3. Line 82 /// Authority PDA, the SPL delegate; signs with the stored bump.: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.

        AccountMeta::writable(a.output_vault.key()),        AccountMeta::readonly(a.in_token_program.key()),        AccountMeta::readonly(a.out_token_program.key()),        AccountMeta::readonly(a.in_mint.key()),        AccountMeta::readonly(a.out_mint.key()),        AccountMeta::writable(a.observation_state.key()),    ];    let ix = Instruction {        program_id: a.amm_program.key(),        accounts: &metas,        data: &data,    };    let bump = [authority_bump];    let seeds = [        Seed::from(AUTHORITY_SEED),        Seed::from(a.mandate.key()),        Seed::from(&bump),    ];    let signer = Signer::from(&seeds);    invoke_signed_with_bounds::<13>(        &ix,        &[            a.authority,            a.amm_authority,

1. Line 325 let bump = [authority_bump];: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
2. Line 326 let seeds = [: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
3. Line 332 invoke_signed_with_bounds::<13>(: Makes a CPI signed by a PDA. The signer seeds prove the program controls that address.