inflation-resistant-token

 // ====================================================================// START: DEFINE ALL INSTRUCTION ACCOUNT STRUCTS HERE// ==================================================================== #[derive(Accounts)]pub struct Init<'info> {    // Note: We need to qualify MAX_BACKING_COUNT with its module    #[account(        init,        space=32 + 8 + size_of::<StableState>()*pricing::MAX_BACKING_COUNT,        payer=irma_admin, seeds=[b"state_v5".as_ref()],        bump    )]    pub state: Account<'info, StateMap>,    #[account(mut)]    pub irma_admin: Signer<'info>,    // Space calculation for Core:    // 8 bytes for discriminator    // 32 bytes for owner (Pubkey)    // 4 bytes for config Vec length + (max 10 configs * ~200 bytes each) = 2004 bytes    // AllPosition struct:    //   - 4 bytes for all_positions Vec length + (max 10 positions * ~300 bytes each) = 3004 bytes      //   - 4 bytes for tokens Vec length + (max 20 tokens * ~200 bytes each) = 4004 bytes

1. Line 82 init,: Creates and pays for a new account. Space and payer must be specified.
2. Line 84 payer=irma_admin, seeds=[b"state_v5".as_ref()],: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
3. Line 85 bump: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
4. Line 89 pub irma_admin: Signer<'info>,: Requires this account to have signed the transaction.

                        .ok_or("MathOverflow").unwrap();                } else {                    let amount_in = Bin::get_amount_in(amount_out, price, swap_for_y)?;                    let fee = lb_pair.compute_fee(amount_in)?;                     total_amount_in = total_amount_in                        .checked_add(amount_in)                        .ok_or("MathOverflow").unwrap();                     total_fee = total_fee.checked_add(fee).ok_or("MathOverflow").unwrap();                     amount_out = 0;                }            }            msg!("-----> amount_out left to quote: {}, total_amount_in: {}", amount_out, total_amount_in);             iterations += 1;            require!(iterations < MAX_ITERATIONS, CustomError::ExceededMaxIterationsQuoteExactOut);             if amount_out > 0 {                lb_pair.advance_active_bin(swap_for_y)?;            }            else {                break;

1. Line 151 .checked_add(amount_in): Uses checked arithmetic so overflow fails instead of wrapping.
2. Line 159 msg!("-----> amount_out left to quote: {}, total_amount_in: {}", amount_out, total_amount_: Logs to the program log, which is visible in explorers and the test output.
3. Line 162 require!(iterations < MAX_ITERATIONS, CustomError::ExceededMaxIterationsQuoteExactOut);: An explicit validation that aborts the instruction with an error.

    Ok(u64::from_le_bytes(amount_bytes))} /// Update token balance in token account datapub fn set_token_balance_in_data(token_account_data: &mut [u8], new_balance: u64) -> anyhow::Result<()> {    if token_account_data.len() < 72 {        msg!("Invalid token account data length");        return Ok(());    }        token_account_data[64..72].copy_from_slice(&new_balance.to_le_bytes());    Ok(())} /// Create program-derived address for testingpub fn create_program_derived_address(seeds: &[&[u8]], program_id: &Pubkey) -> (Pubkey, u8) {    Pubkey::find_program_address(seeds, program_id)} /// Simulate time passage for time-dependent on-chain logicpub fn simulate_time_passage(clock: &mut Clock, seconds: i64) {    clock.unix_timestamp += seconds;    // Approximate slot advancement (400ms per slot)    clock.slot += (seconds * 1000 / 400) as u64;

1. Line 163 msg!("Invalid token account data length");: Logs to the program log, which is visible in explorers and the test output.
2. Line 173 Pubkey::find_program_address(seeds, program_id): Derives a PDA from seeds and the program ID and returns the address with its canonical bump.
3. Line 178 clock.unix_timestamp += seconds;: Reads on-chain time from the Clock sysvar.

impl StateMap {    pub fn new() -> Self {        StateMap {            reserves: Vec::with_capacity(MAX_BACKING_COUNT), // Initialize with capacity for MAX_BACKING_COUNT stablecoins            bump: 0,            padding: [0; 7], // padding to make the size of the struct 25 * EnumCount + 8        }    }     /// Add a stablecoin to the reserves, maintaining the order by symbol.    pub fn add_reserve(&mut self, stablecoin: StableState) {        if self.contains_reserve(&stablecoin.symbol) {            msg!("Stablecoin {} already exists in reserves, skipping addition.", stablecoin.symbol);            return;        }        let clone = stablecoin.clone();        let symbol = clone.symbol; // Get the symbol from the stablecoin        let i = self.reserves.partition_point(|e| e.symbol.as_str() < symbol.as_str());        self.reserves.insert(i, stablecoin);    }     /// Get a stablecoin by its symbol.    pub fn get_stablecoin(&self, symbol: &str) -> Result<StableState> {        require!(symbol.len() <= 8 && symbol.len() > 0, CustomError::InvalidBackingSymbol);

1. Line 305 bump: 0,: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
2. Line 313 msg!("Stablecoin {} already exists in reserves, skipping addition.", stablecoin.symbol);: Logs to the program log, which is visible in explorers and the test output.
3. Line 324 require!(symbol.len() <= 8 && symbol.len() > 0, CustomError::InvalidBackingSymbol);: An explicit validation that aborts the instruction with an error.