A little less
“what does that mean?”
A friendly starting point for the words you keep bumping into. Each definition leads to a deeper explanation.
A complete ERC-20 calldata walkthrough
Separate action selector, recipient and raw token amount.
A contract has an address too
An address can identify code and its state, not only a key-controlled account.
A counter as a contract
A small state variable and one rule make execution easier to picture.
A local-only testing capstone
Build evidence for one small contract without using a public network.
A public key versus a private key
One secret authorizes; public information helps others verify.
A Solidity source file explained
Separate metadata, compiler constraints and declarations before reading function logic.
A tour of the Ethereum ecosystem
The protocol, its interfaces and its applications form different layers.
A transaction journey illustrated
Connect the full sequence through one fictional payment.
A vending machine analogy and its limits
An everyday comparison is useful only while its boundaries remain clear.
A wallet address is not a username
An address identifies an account, without a built-in password-reset desk.
ABI coder version behavior
Compiler generation and decoder checks are separate from the basic layout.
ABI encoding versus packed encoding
Compact concatenation has different boundaries and ambiguity properties.
ABI return values without selectors
Ordinary result data begins with the output tuple encoding.
ABI: the contract’s interface
Turn a function name and typed arguments into bytes.
abi.encodePacked collisions
Variable-width concatenation can erase field boundaries.
Access control mistakes
Sensitive actions need the correct on-chain authority checks.
Access list transactions
Declared accesses participate in a specific transaction and gas model.
Account abstraction for users
Programmable authorization can change how a wallet feels without removing execution costs.
Account nonce versus transaction nonce
A submitted nonce is checked against the account’s execution state.
Account proofs at a glance
A state proof connects an account record to an accepted state root.
Account state fields
Balance, nonce, code and storage commitments answer different questions.
Accounting invariants
State the quantity that must remain conserved or bounded.
Add and subtract exact ETH amounts
Convert to a common whole unit before combining amounts.
ADD, MUL and modular arithmetic
Raw word arithmetic wraps modulo two to the power of 256.
Address poisoning explained
A lookalike address can be planted where you expect useful history.
Addresses and payable addresses
An address representation and permission to use value-transfer syntax are different concepts.
Advanced security scenario set
Combine multiple boundaries instead of checking each feature in isolation.
Anonymous events explained
An anonymous event omits the signature topic.
Application risk knowledge check
Identify the mechanism behind the familiar screen.
Approval race conditions
Replacing an allowance can interact with pending spending.
Approve zero and allowance changes
Changing a standing permission requires attention to ordering.
Arithmetic checks and unchecked blocks
Removing overflow checks requires a proved bound.
Attestations explained
Validators publish structured votes about chain and checkpoint views.
Backups and recovery basics
Understand the exact recovery ingredients before a device is lost.
Base fee explained
A protocol-determined per-gas component changes with block demand under specified rules.
Bitwise AND, OR and XOR
These operations combine corresponding bits across words.
Blob commitments at a glance
A commitment binds data without placing every byte inside the reference.
Blob data in plain language
A separate data channel supports scaling use cases with specific access and retention rules.
Blob-carrying transactions
Blob data availability and EVM calldata have different roles.
Block headers at a glance
Headers summarize relationships and commitments rather than every underlying record.
Block proposers explained
The selected proposer offers a candidate block; the network checks it.
Boolean and integer types
Types define representable values and operations, not economic meaning.
Bounds checks in ABI decoders
Every length calculation must stay inside the available input.
Bridge replay protection
A previously accepted message must not unlock the same claim again.
Bridges as separate risk systems
Moving claims between networks introduces additional verification and custody mechanisms.
Build a dynamic encoding trace
Annotate byte positions before trying to memorize a long hex string.
Build a function selector calculator
Derive the first four digest bytes from a canonical signature.
Build a manual execution fee calculator
Calculate a defined fee component from supplied inputs.
Build a manual fee budget
State your assumptions and keep permitted maximums apart from expected costs.
Build a membership proof
Collect the sibling needed at each step toward the root.
Build a storage packing visualizer
Make slot boundaries and low-order offsets visible.
Build an address checksum checker
Validate byte length and explain what a checksum does.
Build an exact unit converter
Preserve every digit through ETH, Gwei and Wei conversions.
Build and verify a Merkle proof
Reproduce a complete four-leaf membership path.
Builder and proposer separation
Constructing execution content and choosing a proposal can be separated.
Byte offsets and low-order alignment
Offset zero refers to the low-order end of a packed word.
Bytecode versus source code
The EVM executes bytes produced by a compiler, not Solidity text.
Bytes versus hexadecimal display
Hex text is a way to write bytes, not automatically the bytes themselves.
Calculate a function selector
Keep the first four bytes of the canonical signature’s Keccak-256 digest.
Calculate the effective gas price
Apply both caps after checking that base fee is covered.
Call depth and stack limits
Frame nesting and stack item depth are separate constraints.
CALL opcode basics
An external call creates a nested execution frame.
Callback trust boundaries
A callback is an entry point that needs its own authentication.
Calldata load and copy
Read message input as bytes before interpreting an ABI.
Calldata validation and type confusion
Decodable bytes can still represent the wrong intended action.
Calldata versus memory copies
Read-only call input and writable working memory have different roles.
Can a contract be upgraded?
Some application designs can change behavior through explicit upgrade mechanisms.
Canonical bridges versus third-party bridges
An ecosystem’s standard path and another service can use different mechanisms.
Canonical function signatures
Normalize the name and parameter types before hashing a selector.
Checkpoints and finality
Consensus can make a stronger commitment to accepted history.
Checks, effects and interactions
Make the relevant state consistent before handing control away.
Clipboard replacement attacks
Check the destination after pasting, not only before copying.
Code size and deployment limits
Runtime size, init-code size and execution gas are separate constraints.
Commit and reveal patterns
Commit to a choice before exposing the choice and salt.
Compare scaling trust assumptions
Evaluate evidence, data and control rather than a single speed claim.
Composability and shared risk
Applications can connect useful components and inherit their dependencies.
Compute an address mapping slot
Hash the full padded key and declared base slot.
Compute an event signature hash
Topic zero usually identifies the event’s canonical shape.
Contract creation with CREATE
Creation executes initialization code and may return runtime code.
Contract declarations and constructors
Creation-time setup differs from later runtime calls.
Convert ETH to Wei by hand
Move the value into whole Wei without losing any decimal digits.
Convert Wei to ETH by hand
Divide a whole Wei amount by 10¹⁸ to display ether.
Copy addresses without shortcuts
Compare the full destination and its context, not just a short prefix.
Count a billion and a quintillion
Group the zeros before large Ethereum numbers become intimidating.
Count UTF-8 bytes correctly
Visible characters and encoded bytes are different counts.
Cross-chain message authentication
A destination must validate origin and authorized sender, not just decode a payload.
Cross-function reentrancy
A callback can enter a different function sharing the same state.
Cross-language encoding consistency
Typed values should produce the same standard bytes in different implementations.
Custom errors in Solidity
Typed failures can encode useful context compactly.
DAOs and shared decisions
Groups can express some governance rules through contracts and coordinated processes.
Deadlines and signature expiry
Expiry is enforced by verification logic, not by the bytes aging automatically.
Decentralized exchanges explained
Contract rules can coordinate swaps, with dependencies that still need review.
Decentralized identity explained
Identifiers, claims and verification rules can be controlled and checked in different ways.
Decode a complete Transfer receipt
Place a decoded log inside its emitter and receipt context.
Decode a custom Solidity error
The error declaration supplies names and types for its payload.
Decode a dynamic string call
Follow the tuple-relative pointer before reading UTF-8 content.
Decode an Approval event
An allowance record describes spending permission.
Decode an ERC-20 Transfer event
Read two indexed addresses and one raw amount.
Decode Error(string)
A common revert format carries a dynamic message.
Decode multiple return values
Read the output tuple in its declared order.
Decode Panic(uint256)
A panic carries a numeric code instead of a free-form string.
Decode standard and custom reverts
Choose a schema before interpreting failure bytes.
DeFi without the hype
Financial applications built from programmable contracts.
DELEGATECALL and execution context
Use another address’s code while retaining the caller’s state context.
Delegatecall storage collisions
Different slot interpretations can turn an ordinary write into corruption.
Denial of service in loops
Unbounded work can make a required operation impossible to complete.
Deposits and withdrawals
Cross-layer transfers have direction-specific steps and conditions.
Design a beginner-friendly transfer explainer
Teach a first-time learner the path from intent to finality.
Deterministic creation with CREATE2
Creator, salt and init-code hash determine a candidate address.
Differential testing
Compare independent implementations on the same defined input.
Digital collectibles beyond speculation
Individually tracked items can support membership, games and other experiences.
Disconnecting is not revoking approval
A website connection and an onchain allowance live in different places.
Display units versus raw units
A friendly number and a machine integer can describe the same amount.
Document contract assumptions
Make hidden environmental requirements reviewable.
Domain separation explained
Bind a digest to the intended protocol context.
Donation and inflation attacks
Unsolicited assets can change share-conversion ratios in some vault designs.
Double-hashed leaf conventions
Some standard tree formats hash encoded leaves twice.
Dust and very small balances
A tiny amount can be exact even when moving it costs more than the amount itself.
Dynamic array base slots
The declared slot holds length while a hash-derived region holds elements.
Dynamic arrays of static tuples
The array is dynamic even when every tuple element has fixed width.
EIP-155 replay protection
Legacy transaction signing can bind a chain identifier.
EIP-1559 in plain language
A block base fee and transaction fee caps replace a single-price mental model.
EIP-1559 transaction fields
Fee caps express limits rather than a guaranteed paid price.
EIP-712 domain mistakes
Signing and verification must agree on the intended domain fields.
EIP-712 domain separators
Typed signing binds structured content to a specified domain.
EIP-712 typed structs
Type definitions participate in the signed digest.
Elliptic curve intuition
A public key is derived through a one-way group operation.
Emergency controls and governance risk
A protection mechanism also grants authority.
Empty revert data explained
A failed call can return no diagnostic bytes at all.
Empty strings and empty arrays
Empty content still has a valid dynamic encoding.
Encode a boolean word
The boolean schema uses canonical zero or one values.
Encode a string array
Element offsets use the array element tuple as their base.
Encode a token transfer by hand
Assemble one selector and two full argument words.
Encode a uint256 array
Dynamic arrays begin their tail with an element count.
Encode an address word
Twenty address bytes occupy the lower-order part of a word.
Encode bytes4 versus bytes32
Fixed bytes are right-padded, unlike unsigned integers.
Encode one string
A single dynamic argument still has an offset word.
Encode signed integers
Negative values use two’s-complement and sign extension.
Encode two dynamic arguments
Later tails begin after the full earlier tail.
Encode uint256 step by step
An unsigned integer occupies one left-padded 32-byte word.
ENS names explained
A naming system can map a readable name to records under its rules.
ERC-1155 multiple token types
One contract can manage balances for several item IDs.
ERC-1271 contract signatures
A contract account can validate signatures under its own policy.
ERC-1271 validation assumptions
Contract-account approval can depend on current state and external calls.
ERC-20 return value differences
Integration code must handle actual token call conventions.
ERC-721 ownership and token IDs
A standard ownership query names one individually tracked token.
Errors can be bubbled up
A caller can pass a child’s failure bytes onward.
ETH, Gwei and Wei
The same amount of ether, measured with different sized rulers.
Ethereum address derivation
An EOA address is derived from a public key, not directly from its display text.
Ethereum tries versus binary Merkle trees
A simple binary playground is not an execution-state proof implementation.
Ethereum versus Bitcoin
Two networks with different designs, assets and trade-offs.
Ethereum versus the internet
Ethereum uses the internet; it does not replace the whole thing.
Event ordering in nested calls
Nested execution can interleave logs from different emitters.
Events in a contract
Logs help applications observe defined execution records.
Events versus actual token behavior
A log is a record emitted by code, not a universal guarantee of balance movement.
Events, topics and logs
Read the structured notes that contracts leave during execution.
Execution clients and consensus clients
Two cooperating roles check execution and follow proof-of-stake consensus.
Execution fees versus blob fees
Blob-carrying transactions have an additional data-resource dimension.
Execution payloads explained
Execution data and consensus organization have different responsibilities.
Explain a rollup to a new learner
Separate execution, data availability and settlement assumptions.
Fee-on-transfer tokens explained
The requested amount and the recipient’s net increase can differ.
Finality failures and recovery
Loss of finalization and conflicting finality are different conditions.
Fixed array storage layout
Small array elements can pack within their reserved region.
Fixed arrays of dynamic values
A fixed element count can still contain dynamic content.
Fixed bytes versus dynamic bytes
A fixed-size byte value differs from a variable-length byte sequence.
Fixed-size arrays in the ABI
A fixed count does not automatically make the entire value static.
Flash loans as a mechanism
Atomic borrowing changes available temporary capital, not arithmetic truth.
Follow a transaction
From pressing send to becoming part of the shared history.
Fork choice in plain language
A node needs a rule for choosing its current valid chain head.
Fork testing and its limits
A copied chain state is a particular test fixture, not a future guarantee.
Fraud proofs and challenge periods
A dispute process needs evidence, access and time to work.
Frontend security versus contract security
A correct contract and a trustworthy interface are separate requirements.
Function overloads and selectors
The same name can identify different input-type signatures.
Function parameters and return values
Inputs and outputs have typed ABI shapes with different call-data framing.
Functions and arguments explained
A function identifies an action; arguments supply the details.
Functions and visibility
Call reachability and business authorization are separate layers.
Fuzz testing explained
Generate many inputs for a stated property.
Gas as a measure of work
Resource accounting and the price of that resource are separate quantities.
Gas calculation practice set
Use both units and fee caps to explain a result.
Gas forwarding and the 63/64 rule
A requested gas amount is subject to forwarding rules.
Gas limit versus block gas limit
A transaction budget and a block’s resource constraint apply at different scopes.
Gas refunds and refund limits
A refund counter follows specific rules and is capped.
Gas snapshots and their limits
A measured cost belongs to a specific build and execution context.
Gas used versus gas limit
A ceiling on work is different from the work actually consumed.
Gas without the guesswork
Gas measures work. A gas price tells you what that work costs.
Governance proposals and voting
A proposal’s bytes and execution conditions matter alongside its description.
Hardware wallets still need careful review
Protecting a key does not automatically explain a request’s meaning.
Hash a Merkle leaf
The leaf encoding is part of the tree definition.
Hash a pair of nodes
Combine two fixed-width digests under an explicit rule.
Hash preimages and collisions
Finding an input for a digest differs from finding two matching digests.
Hashes: fingerprints for data
The same input gives the same fingerprint; a tiny edit changes it.
Head and tail encoding
Keep fixed-width heads separate from variable-sized payloads.
How are blocks linked?
Each new block points to the fingerprint of its parent.
How ERC-20 balances are recorded
A token contract defines how an account’s quantity is represented.
How Ethereum agrees
Validators propose and vote; nodes check that the rules hold.
How to read a faucet warning
Separate a legitimate service condition from a request for secret access.
Indexed strings and hashed topics
An indexed string topic is a digest, not recoverable text.
Indexed versus non-indexed arguments
The declaration decides which values become topics.
Inheritance and storage ordering
Inherited declarations participate in the final instance layout.
Init code versus runtime code
Deployment instructions and installed instructions have different jobs.
Inspect a delegatecall trace
Track code source and state owner as separate columns.
Interest rate models at a glance
A rate can depend on pool state and a contract-defined formula.
Interfaces and inheritance basics
Shared declarations and inherited implementation have different jobs.
Invariant testing explained
Generate action sequences while checking a property after each step.
JUMP, JUMPI and JUMPDEST
Control flow must target a valid destination instruction.
Keccak-256 versus SHA3-256
Similar names do not make two digest algorithms interchangeable.
Layer 1 versus layer 2
Execution can happen on another system while settlement relates back to Ethereum.
Layer 2 and rollups
Do more work elsewhere, with verification tied back to Ethereum.
Layer 2 fee components
Execution and data-related costs can be combined differently by each network.
Layer 2 scenario practice
Separate immediate feedback, publication, settlement and exit rights.
Leaf encoding ambiguity
A secure digest cannot fix an ambiguous original encoding.
Lending and collateral
Borrowing systems define rules for debt, security and repayment.
Link an error to a call frame
Find the first failing frame and the callers that handled it.
Liquidation edge cases
Price, collateral and rounding boundaries jointly determine eligibility.
Liquidation explained
A system can permit closing or reducing a position when its conditions are breached.
Liquidity pools explained
A pool’s reserves and pricing rule shape what a swap can receive.
LOG opcodes and topics
Logs are explicit EVM effects with memory data and up to four topics.
Logs inside a receipt
A receipt places surviving log records in transaction context.
Long bytes and strings in storage
Long content moves to a hash-derived data region.
Low-level trace challenge set
Explain context, outcome and surviving effects together.
Malformed offsets and decoding failures
A word that looks like an offset can point outside the supplied data.
Malleability and signature normalization
Different signature encodings can relate to the same authorization.
Mapping entry slot calculations
Hash the properly encoded key with the declared mapping slot.
Mapping to a struct
A mapping hash selects the struct’s base slot.
Maximum fee cap explained
The maximum per-gas rate sets a ceiling, not a fixed quote.
Memory expansion basics
Accessing farther memory can increase execution cost.
Merkle allowlists explained
A contract can check membership without storing every entry individually.
Merkle proof challenge set
Explain leaf encoding, path rules and root authority as one system.
Merkle proof leaf ambiguity
Leaf and branch encodings need an unambiguous separation.
Merkle trees and proofs
Prove that one item belongs to a set using a short path of hashes.
Metadata and token ownership differ
A token’s owner record and its descriptive data are separate claims.
MEV and proposer incentives
Ordering and inclusion choices can affect economic outcomes.
MLOAD and MSTORE
Word operations use byte-addressed temporary memory.
Mocks versus real dependencies
A mock tests selected behaviors, not every property of a real integration.
Modifiers and access checks
Reusable wrappers can enforce conditions, but the full code path matters.
msg.sender versus tx.origin
The immediate caller and transaction originator can differ.
msg.value in nested calls
Value belongs to a particular call context.
Multiproofs at a glance
Several leaves can share intermediate reconstruction work.
Namespaced storage explained
Modules can derive separate roots for structured state.
Native transfers versus token transfers
Sending ETH and asking a token contract to update balances use different fields.
Nested ABI challenge set
Resolve a nested layout and justify every offset base.
Nested dynamic array walkthrough
Each dynamic array layer has a count and its own element region.
Nested mappings explained
Apply the mapping derivation once for each key layer.
Nested tuple offset bases
Draw a separate origin for every nested dynamic tuple.
Network architecture knowledge check
Connect verification, consensus, providers and local tools without mixing their roles.
Network IDs and chain IDs
Identifiers have protocol roles beyond a wallet’s editable display name.
Nodes and the shared state
Computers that check the rules instead of trusting someone else’s copy.
Nodes versus validators
Verifying the chain and participating with stake are distinct roles.
Nonces and replay protection
A valid authorization may need to be usable only once.
Odd leaf construction choices
An unmatched node needs a documented construction rule.
Onchain versus offchain metadata
Find which parts of a description depend on the chain and which depend on another service.
One recovery phrase, many accounts
A deterministic key tree can produce several account identities.
Optimistic rollups explained
State claims can be accepted provisionally under a challenge mechanism.
Oracle manipulation basics
A quoted value is only as robust as its source and update rules.
Oracles in financial apps
Price inputs can determine borrowing, liquidations and swaps.
Pack adjacent value types
Compatible small fields can share one slot.
Padding dynamic bytes
The payload is right-padded while its length remains exact.
Payments with Ethereum
A transfer combines an asset amount with a network and destination.
Peer-to-peer networking basics
Nodes exchange data through many connections rather than one universal message queue.
Pending, confirmed and finalized
Different stages answer different questions about a transaction.
Personal message signing prefixes
Personal-message hashing prefixes the exact message length and bytes.
Pragma directives and compiler versions
A source constraint and the compiler actually used are different pieces of evidence.
Precision loss across decimals
Conversion order and rounding can destroy small values.
Precompiles in the EVM
Special addresses can expose protocol-defined computation.
Predictable randomness
Public or influenceable inputs do not automatically form a fair draw.
Prepare a personal transaction checklist
A short review can keep different kinds of evidence from being mixed up.
Price impact versus slippage
Your trade can move a price, while execution can also differ from a prior quote.
Priority fee explained
The effective tip can be lower than the requested priority cap.
Proof size and tree depth
Balanced binary trees provide logarithmic-sized membership paths.
Property-based ABI round trips
Encoding and decoding should agree under the exact schema.
Protocol reading challenge set
Identify the rule, its context and the evidence required for a claim.
Protocol upgrades and EIPs
A proposal, reviewed specification and activated rule are different stages.
Proxy admin and implementation risks
Upgrade authority and application authority may be separate paths.
Public does not mean anonymous
Addresses are pseudonyms, and public activity can reveal connections.
Public goods funding explained
Communities can support shared resources through several allocation mechanisms.
Publish a source-linked technical lesson
Pair simple wording with reproducible evidence and a precise reference.
PUSH, DUP and SWAP
Introduce, copy and rearrange stack values.
Read a complete small contract
Trace inputs, permission, state and logs in one self-contained example.
Read a domain carefully
A familiar brand name inside a URL is not enough.
Read a simple transfer receipt
Use a fictional receipt to connect status, gas and block context.
Read a very large integer
Use groups and units to make long numbers legible without changing them.
Read a wallet confirmation screen
Check what you authorize, including details a friendly button can hide.
Read an allowance
Identify the owner, spender, token and network behind the number.
Read arithmetic panic codes
Different runtime failures can use different numeric categories.
Read calls versus write transactions
Simulation, submission and accepted state updates are separate operations.
Read compiler errors
Find the actual failing location before changing unrelated code.
Read compiler storage output
Use slot, offset and type information together.
Read your first Solidity contract
Variables hold values. Functions describe the changes you allow.
Read-only practice habits
Learn byte shapes and public data before authorizing real actions.
Read-only reentrancy
A callback can exploit an inconsistent observation without writing through a view function.
Reading a contract versus changing it
A local read can simulate execution; persistent updates need accepted transaction processing.
Reading your first block explorer page
Learn the labels before treating a receipt as a complete story.
Rebasing tokens explained
A balance can change through a supply-adjustment mechanism rather than an ordinary transfer.
Receipt and error challenge set
Combine event decoding, rollback and failure context.
Receipts roots explained
Receipts have their own block commitment.
Receive and fallback functions
Special entry points handle certain calls outside ordinary named-function dispatch.
Recognize a recovery phrase scam
A request for the master backup is a request for control.
Recovering an externally owned signer
Recovery identifies a candidate signer for one digest and signature.
Reentrancy across call frames
An external handoff can lead back into unfinished application logic.
Reentrancy explained with a counterexample
An unfinished withdrawal can expose an old entitlement to a callback.
Require, revert and assert
Failure mechanisms express different conditions and error shapes.
Return data and copying
A child call leaves a result buffer separate from its success flag.
Return-data griefing explained
Large attacker-controlled output can make caller-side processing expensive.
Review a pull request for safety
Connect a change to its affected invariants and authority.
Review a signature permission request
Explain exactly which action the signer would authorize.
Review an upgrade storage change
Preserve old state meaning while reviewing new authority.
Rounding direction in financial code
Integer rounding can shift value between participants.
Rounding versus truncation
Discarding digits and choosing the nearest display value are different operations.
Safety scenario challenge
Practice identifying what a request actually grants.
secp256k1 keys at a glance
Ethereum EOA signing uses a specific curve and valid scalar range.
Security review practice set
Review authority, invariants and progress under hostile conditions.
Selector collisions explained
Four bytes cannot uniquely label every possible function signature.
SELFDESTRUCT after protocol changes
Historical deletion assumptions do not describe every modern case.
Sequencer availability and escape paths
A fallback must work under the conditions where the ordinary path fails.
Set up a local Solidity project
Keep source, compiler settings and tests together.
Settlement versus execution
Running a transaction and committing to its accepted result are related but different stages.
Shifts and byte extraction
Shift direction and byte numbering must be stated explicitly.
Short bytes and short strings in storage
Up to thirty-one bytes can share a slot with their length marker.
Signature r, s and v fields
Signature components need a stated encoding and signing context.
Signature replay across chains
A message accepted on one chain may be accepted elsewhere without proper binding.
Signature verification practice set
Check digest construction, account policy and replay rules together.
Signatures and permissions
Prove authorization without sharing the secret that creates it.
Signed arithmetic opcodes
The same word bits can be interpreted as signed or unsigned.
Signed versus unsigned integers
Negative values require a representation and range appropriate to the task.
Slippage and sandwich attacks
Transaction ordering can worsen an execution price.
SLOAD and SSTORE
Storage access uses slot keys in the current storage context.
Smart contract knowledge check
Connect interfaces, execution, persistent state and trust boundaries.
Smart contracts, simply
Programs that apply rules on Ethereum.
Software wallets and hardware wallets
Different places to keep keys and perform signing, with different trade-offs.
Solidity storage slots
See how persistent values fit into 32-byte slots.
Sorted pairs versus ordered pairs
Position-sensitive and commutative trees require different proof rules.
Spot a fake support message
A helpful tone is not proof of authority.
Stablecoin mechanisms at a glance
A target price depends on a design, not on the word stable.
Stablecoins for everyday use
A familiar price target does not remove network, issuer or contract assumptions.
State rollback boundaries
A child failure and a top-level failure have different enclosing scopes.
State roots versus transaction roots
Different roots commit to different parts of a block’s execution context.
State variables versus local variables
Persistence depends on where a value lives and how it is updated.
Static ABI decoding challenge set
Use the schema, padding and complete static width together.
Static context restrictions
Read-only execution rules extend across nested execution.
Static tuples explained
A tuple of static members concatenates their encodings without an offset to a tail.
STATICCALL explained
Read-only execution context prohibits state-changing operations.
Stay safe while exploring
Build good habits before you connect a real wallet.
Step inside the EVM
A stack machine that turns bytecode into checked state changes.
STOP, RETURN and REVERT
Halting instructions differ in output and state outcome.
Storage layout and proxies
Delegate execution makes layout compatibility part of correctness.
Storage layout challenge set
Combine packing, derived slots and data-location boundaries.
Storage proofs at a glance
Connect a slot claim through the account’s committed storage root.
Storage writes and gas
Persistent updates have costs that depend on the state transition.
Strings and UTF-8
Byte length and visible character count can differ.
Struct storage layout
A struct starts a fresh slot and packs its own members.
Test access control
Exercise allowed callers and rejected callers.
Test ETH versus real ETH
The same unit names do not make separate networks’ assets interchangeable.
Test event emission
Verify emitter, topics, data and rollback behavior.
Test revert data
Check the failure schema and state outcome.
Test storage invariants
Check logical state properties across every modifying path.
Test token decimals
Keep raw integers and display scaling separate.
The 21,000 gas transfer example
A narrow simple case is useful without being a universal transfer estimate.
The 256-bit stack
EVM stack items are full-width words with limited depth.
The 32-byte storage word
Storage reads and writes address full words.
The ERC-20 decimals convention
A metadata method helps applications format a raw token integer.
The fee recipient
Execution rewards and burned fees have different destinations.
The free memory pointer
Solidity stores its allocation pointer at memory address 0x40.
The JSON ABI format
Structured interface entries describe functions, events and errors.
The program counter
Instruction positions are byte offsets into the executing code.
The recipient versus the sender
Who authorizes a transaction can differ from who receives an asset.
The state transition function
Valid inputs transform one state into a defined next state.
Threat-model a token approval flow
Follow permission from the interface to later spending.
Timestamp dependence
A block timestamp is a protocol input with boundary assumptions.
Token hook reentrancy
A token interaction may invoke additional code.
Token interface practice set
Distinguish identity, amounts, permissions and event layouts.
Tokens, NFTs and allowances
Contracts keep ownership records; standards make them easier to use.
Total supply versus circulating supply
Contract accounting and estimates of market availability answer different questions.
Trace a failed token transfer
Separate the call result, return value and state effects.
Trace a small EVM program
Track byte positions and stack changes before reasoning about state.
Trace a tiny stack program
Decode immediate bytes and record each stack transition.
Trace calldata byte by byte
Find the selector, split the words, and follow dynamic offsets.
Trace proxy fallback execution
A fallback can forward input and return the delegated outcome.
Transaction basics knowledge check
Use the right evidence for ordering, cost, execution and settlement.
Transaction context versus call context
One transaction can contain several message-call contexts.
Transaction types and envelopes
A type identifier selects the transaction payload format.
Transaction value versus fee
The native amount sent and the cost of execution are separate.
Transient storage explained
Transaction-scoped state differs from both persistent storage and per-frame memory.
Trusting an RPC provider
A convenient access point adds assumptions about answers, privacy and availability.
Tuples containing strings
One dynamic component makes the tuple dynamic.
Unbounded storage growth
Persistent collections need a plan for future access costs.
Understand a receive screen
A receiving address is useful only with the right network and asset context.
Understand relative offsets
An offset is useful only when you know its starting point.
Understand token approvals
An allowance lets a specified spender request token movement under contract rules.
Understand transfer and transferFrom
Moving your own tokens and spending with permission use different interfaces.
Understand why a call reverted
Separate error bytes from the underlying reason execution failed.
Uninitialized contracts and initializers
An exposed setup function can become an unintended ownership path.
Unit conversion practice set
Check the scale, preserve the integer, and verify your result.
Unit tests for a counter
Assert a small operation’s before-and-after behavior.
Unlimited allowances explained
A very large spending permission can expose more than the next intended payment.
Unsafe external call assumptions
Targets can fail, reenter or return unexpected data.
Upgrade authorization failures
An upgrade path can bypass otherwise correct application permissions.
Validator lifecycle overview
Joining, participating, exiting and withdrawing are separate stages.
Validator rewards and penalties
The protocol gives incentives for correct participation and costs for failures.
Validity proofs and verification
The checked statement matters as much as the proof’s name.
Validity rollups explained
A verifier checks a proof that a state transition follows the encoded rules.
Value transfer and call failures
A value-bearing call can fail and must be handled deliberately.
Verify a membership proof
Recompute the path and compare it with the accepted root.
Verify an address through two channels
Independent confirmation can catch a changed or impersonated destination.
Verify deployed source conceptually
Reproduce the relevant compiled artifact under matching settings.
Verkle trees as a design direction
Study a proposed commitment design without treating it as an activation promise.
View and pure functions
State-access restrictions differ from whether execution happens inside a paid transaction.
Voting power versus ownership
Control rights are defined by mechanisms rather than a universal one-token meaning.
Walk through a pretend contract call
Follow one input from the interface to its checked state update.
Wallet safety knowledge check
Put account access, networks and permissions into one simple review.
Wallets, keys and addresses
Your address receives things. Your keys authorize things.
Warm versus cold access overview
Access history within a transaction can affect some resource costs.
Watch-only wallets
A public view of an account without the power to sign for it.
Weak subjectivity explained
A long-offline proof-of-stake node needs an appropriately trusted recent checkpoint.
What a block explorer label does not prove
Human-friendly tags are interpretations layered onto network data.
What a blockchain cannot prove
Correct execution does not make every input truthful or every outcome useful.
What a light client checks
A lighter verification design uses authenticated summaries and proofs under stated assumptions.
What a testnet is for
A separate network lets people practice protocol and application behavior.
What a wallet actually stores
The app manages access; the network records balances.
What an ABI describes
The interface tells software how to format requests and results.
What an archive node retains
Historical state access differs from merely retaining block history.
What are token decimals?
A token’s display scale tells you where to place the decimal point.
What are wallet networks?
A wallet can connect to different chains, each with its own state.
What can a blockchain prove?
It can verify rule-following records, but external claims need extra trust.
What contracts cannot do alone
Deterministic execution needs explicit inputs and a trigger.
What does a full node verify?
It applies protocol rules rather than accepting a provider’s labels as proof.
What does a token balance mean?
A number reported under a token contract’s rules, not a universal cash value.
What does a token standard guarantee?
An interface specification supports interoperability, not universal safety.
What does burning mean?
The word can describe different mechanisms for removing assets from usable supply.
What does canceling a transaction mean?
A wallet’s cancel action often submits a competing request; it is not an undo switch.
What does connecting a wallet allow?
Connection is one permission step; signing and spending authorization are separate.
What does contract state mean?
The values a contract currently remembers after accepted updates.
What does decentralization mean?
Control and verification are spread across participants.
What does minting mean?
Creating units under a protocol or contract’s rules.
What happens after pressing send?
A wallet action begins a process with several observable stages.
What happens in a slot?
The consensus schedule gives an opportunity for a block proposal.
What happens in an epoch?
Groups of slots provide a larger structure for consensus duties and checkpoints.
What happens to unused gas?
A gas limit is a permitted ceiling rather than a requirement to consume it.
What happens when gas runs out?
Execution cannot keep working after exhausting its permitted resources.
What is a blockchain?
A shared notebook that lots of computers check together.
What is a chain reorganization?
A node can replace its view of recent unfinalized blocks with another valid branch.
What is a contract wallet?
An account whose authorization rules can be implemented through code.
What is a derivation path?
A set of instructions for choosing a branch in a deterministic key tree.
What is a digital ledger?
A record of who owns what, or what changed, kept as data.
What is a malicious signature?
A valid signature can authorize an action the signer did not intend.
What is a mempool?
A node’s local collection of pending transaction candidates.
What is a multisignature wallet?
A policy requiring several approvals before an action is allowed.
What is a network fee?
A charge for the network resources used to process an action.
What is a nonce?
An account’s transaction sequence helps keep instructions in order.
What is a permission check?
A rule determines whether the current caller may perform an action.
What is a recovery phrase?
A human-readable secret that can restore key material for compatible wallets.
What is a replacement transaction?
A competing instruction can target the same sender nonce.
What is a rollup batch?
Many local transactions can contribute to one published unit of information.
What is a sequencer?
An ordering service can give a rollup its immediate transaction sequence.
What is a sidechain?
A separate chain can connect to Ethereum while using a different consensus security model.
What is a transaction hash?
A fingerprint identifies encoded transaction data; it is not a success certificate.
What is a transaction receipt?
A result record for a transaction included in a block.
What is a transaction?
An authorized instruction asking Ethereum to update its state.
What is an administrator key?
Some systems give an account special powers over configuration or upgrades.
What is an Ethereum account?
An entry in Ethereum’s state, identified by an address.
What is an oracle?
A mechanism for supplying information a contract cannot directly observe.
What is contract bytecode?
Machine-readable instructions differ from human-readable Solidity.
What is data availability?
Participants need access to the data required to reconstruct or check the system.
What is deployment?
Creation execution can install runtime code at a new contract address.
What is Ethereum?
A shared computer that anyone can use and anyone can check.
What is verified source code?
A source match helps inspection but does not certify safe behavior.
What makes a block a block?
A batch of ordered transactions plus information needed to check it.
What makes an NFT unique?
A token ID distinguishes an item within its contract’s collection.
What makes ETH different from tokens?
Native ETH is part of Ethereum’s accounting; a token follows its own contract.
What slashing means
Some conflicting validator actions can be proven and penalized by the protocol.
Where NFT images can live
The token may point to media hosted somewhere else.
Who can call a smart contract?
Reachability and permission are different questions.
Who can use Ethereum?
The protocol is open, while individual services can set their own conditions.
Who includes a transaction?
A block proposal chooses candidate transactions, while nodes verify the result.
Who owns Ethereum?
No company owns the protocol in the way a company owns its private app.
Why a converter is not a price feed
Unit conversion is fixed arithmetic; a market quote is changing external data.
Why a revert still costs gas
Rolling back state does not erase computation already performed.
Why a transaction may fail
Rejection before inclusion differs from a revert during execution.
Why a transaction may wait
Fee conditions, nonce gaps and propagation can all delay inclusion.
Why a trusted root matters
A proof is only as relevant as the root it is checked against.
Why ABI data is not self-describing
A valid word can support several different interpretations.
Why an airdrop can be bait
An unsolicited asset can be used to lure someone into a separate harmful action.
Why balances differ across networks
Matching address text does not mean shared account state.
Why bugs can be expensive
Public execution can apply an unintended rule just as faithfully as an intended one.
Why client diversity matters
Independent implementations can reduce dependence on one shared software bug.
Why do computers need to agree?
The order of valid updates can change the answer.
Why estimates can be wrong
Simulation describes particular inputs and state, while real execution may occur later.
Why Ethereum uses whole numbers
Count the smallest units, then format them for people.
Why floating-point amounts can fail
Ordinary JavaScript numbers cannot preserve every possible Wei amount.
Why revert bytes can be spoofed
Recognizing an error format does not authenticate its author.
Why reverted logs do not persist
Rollback removes logs from the reverted execution scope.
Why token names are not identities
Names and symbols can be reused by unrelated contracts.
Why transactions are usually irreversible
Accepted state changes do not have a universal user-operated undo button.
Why withdrawal timing differs
Proof systems, challenge rules and service models lead to different timelines.
Withdrawal processing basics
Consensus-related withdrawals are not ordinary user-signed contract calls.
Wrapped ETH explained
A contract representation can make ETH usable through a token-style interface.
Write a payment instruction
An amount needs a destination, network and authorization context.
Write a safe learning sandbox
Make experiments useful without requiring real assets or secrets.
Write a threat model
Describe assets, actors and trust boundaries before listing attacks.
Your Ethereum learning portfolio
Connect your explanations, byte traces and local tools into a reviewable set.
Your first blockchain knowledge check
Put the shared notebook, its rules and its limits together.