DePIN-Reward-Float

#[derive(Accounts)]pub struct InitConversionVault<'info> {    // The pool authority: the tolerance of FR-015a decides when withholding is skipped,    // and the first caller would otherwise set it for the pool.    #[account(mut)]    pub authority: Signer<'info>,     #[account(has_one = authority @ RewardFloatError::NotPoolAuthority)]    pub pool: Box<Account<'info, Pool>>,     #[account(        init,        payer = authority,        space = 8 + ConversionVault::INIT_SPACE,        seeds = [CONVERSION_SEED, pool.key().as_ref(), reward_mint.key().as_ref()],        bump,    )]    pub conversion_vault: Box<Account<'info, ConversionVault>>,     pub reward_mint: Box<Account<'info, Mint>>,     #[account(address = pool.stable_mint)]    pub stable_mint: Box<Account<'info, Mint>>,

1. Line 18 pub authority: Signer<'info>,: Requires this account to have signed the transaction.
2. Line 20 #[account(has_one = authority @ RewardFloatError::NotPoolAuthority)]: Checks that a stored pubkey field matches the passed account.
3. Line 24 init,: Creates and pays for a new account. Space and payer must be specified.
4. Line 27 seeds = [CONVERSION_SEED, pool.key().as_ref(), reward_mint.key().as_ref()],: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
5. Line 28 bump,: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.

const BASIS_POINTS: u16 = 10_000; // The rate is in stablecoin base units for this many reward base units.const RATE_UNIT: u128 = 1_000_000_000_000; #[derive(Accounts)]#[instruction(nonce: u64)]pub struct Borrow<'info> {    #[account(mut)]    pub operator: Signer<'info>,     #[account(mut, has_one = vault)]    pub pool: Box<Account<'info, Pool>>,     // Opened by the first loan rather than by an instruction of its own, so that    // borrowing stays one transaction signed by the operator (FR-008).    #[account(        init_if_needed,        payer = operator,        space = 8 + OperatorAccount::INIT_SPACE,        seeds = [OPERATOR_SEED, operator.key().as_ref()],        bump,    )]    pub operator_account: Box<Account<'info, OperatorAccount>>,

1. Line 22 pub operator: Signer<'info>,: Requires this account to have signed the transaction.
2. Line 24 #[account(mut, has_one = vault)]: Checks that a stored pubkey field matches the passed account.
3. Line 30 init_if_needed,: Creates the account only if it doesn't exist. Watch for re-initialisation bugs.
4. Line 33 seeds = [OPERATOR_SEED, operator.key().as_ref()],: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
5. Line 34 bump,: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.

use anchor_lang::prelude::*;use anchor_spl::token::{self, Token, TokenAccount, Transfer}; use crate::error::RewardFloatError;use crate::state::{LenderShare, Pool, SHARE_SEED}; #[derive(Accounts)]pub struct Deposit<'info> {    #[account(mut)]    pub lender: Signer<'info>,     #[account(mut, has_one = vault)]    pub pool: Box<Account<'info, Pool>>,     // Opened by the first deposit, so that lending stays one transaction.    #[account(        init_if_needed,        payer = lender,        space = 8 + LenderShare::INIT_SPACE,        seeds = [SHARE_SEED, pool.key().as_ref(), lender.key().as_ref()],        bump,    )]    pub lender_share: Box<Account<'info, LenderShare>>,

1. Line 10 pub lender: Signer<'info>,: Requires this account to have signed the transaction.
2. Line 12 #[account(mut, has_one = vault)]: Checks that a stored pubkey field matches the passed account.
3. Line 17 init_if_needed,: Creates the account only if it doesn't exist. Watch for re-initialisation bugs.
4. Line 20 seeds = [SHARE_SEED, pool.key().as_ref(), lender.key().as_ref()],: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
5. Line 21 bump,: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.

            }            emit!(SweepSkipped {                operator,                reward_mint,                withheld: total_withheld,                stable_per_trillion_reward: rate,                deviation_bps: check.deviation_bps,                max_slippage_bps: conversion.max_slippage_bps,            });        } else {            let operator_seeds: &[&[u8]] = &[                OPERATOR_SEED,                operator.as_ref(),                &[ctx.accounts.operator_account.bump],            ];            token::transfer(                CpiContext::new_with_signer(                    ctx.accounts.token_program.to_account_info(),                    Transfer {                        from: ctx.accounts.reward_account.to_account_info(),                        to: ctx.accounts.reward_vault.to_account_info(),                        authority: ctx.accounts.operator_account.to_account_info(),                    },                    &[operator_seeds],

1. Line 242 emit!(SweepSkipped {: Emits an Anchor event that clients can parse from the logs.
2. Line 254 &[ctx.accounts.operator_account.bump],: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
3. Line 256 token::transfer(: An SPL token transfer through the Token Program.
4. Line 257 CpiContext::new_with_signer(: Makes a CPI signed by a PDA. The signer seeds prove the program controls that address.