As a Solana Engineer, Please slap yourself if you cannot clearly explain at least 10 of the following: Accounts model vs account-based chains Program Derived Addresses (PDAs) Seeds & bump mechanics Account ownership rules Rent exemption mechanics Lamports vs SOL accounting System Program responsibilities Upgradeable program loader internals Instruction serialization (Borsh vs Anchor) Transaction message structure Versioned transactions (v0) Address Lookup Tables (ALTs) Compute budget & compute units Priority fees & fee markets Transaction simulation vs execution Preflight checks Atomic transaction guarantees Cross Program Invocation (CPI) mechanics Reentrancy in Solana (why it differs from EVM) Signer authorization model Writable vs readonly accounts Account locking & parallel execution Sealevel runtime scheduling Optimistic concurrency model Deterministic execution constraints Transaction size limits (1232 bytes problem) Account data layout design Zero-copy accounts Account realloc patterns Serialization cost vs compute tradeoffs Anchor discriminator logic Anchor account validation pipeline Constraint macros under the hood IDL generation & client binding Anchor events vs logs Program logs & debugging strategy LiteSVM vs local validator testing Test validator architecture Sysvars (Clock, Rent, Instructions, SlotHashes) Slot vs block vs epoch Proof of History (PoH) mechanics Leader schedule & block production Turbine block propagation Gulf Stream transaction forwarding QUIC networking in Solana Replay stage & fork choice Commitment levels (processed/confirmed/finalized) RPC consistency guarantees State compression basics Merkle tree accounts Concurrent Merkle Trees Compressed NFTs architecture Token Program vs Token-2022 extensions Associated Token Accounts derivation Mint authority vs freeze authority Delegation mechanics Metaplex metadata accounts Candy Machine architecture On-chain randomness limitations Oracle design patterns (Pyth/Switchboard) Price update verification Upgradeable program security risks Program authority management Multisig program patterns Escrow design patterns Time-locked accounts Vesting contract mechanics Replay attack prevention Signature verification flow Ed25519 program usage Secp256k1 verification program Compute exhaustion attacks Account inflation attacks Rent draining vectors CPI depth limits Stack frame limits Heap allocation constraints Deterministic randomness strategies Idempotent instruction design State machine modeling on-chain Instruction replay safety Optimistic UI vs finalized state Indexer architecture (Helius/Triton style) Websocket subscriptions vs polling Event indexing from logs RPC rate limiting strategies Transaction confirmation UX design Wallet adapter lifecycle Phantom signing flow internals Partial signing transactions Durable nonce accounts Offline transaction signing MEV on Solana Jito bundles & block engines Priority fee auctions Transaction landing optimization Failed transaction debugging workflow Compute profiling techniques Program size optimization BPF execution model LLVM → SBF compilation pipeline Stack vs heap limits in SBF Program deployment lifecycle Upgradeable buffer accounts Devnet vs mainnet behavioral differences Forks & rollback handling State migration strategies Backward-compatible account upgrades