The File and the Dialect

A block comment, and the largest single thing in the file so far. The triple markers and the `@dev` tag make it NatSpec, Solidity's documentation convention: still a comment, still invisible to the machine, but in a shape that tooling and wallets can read.

Read it and you know the author's intent before you read a line of code. Then carry one caution. Documentation is a claim, not a guarantee. The code below does what it does regardless, and a comment that has drifted from the code beneath it is one of the most common things in real contracts.

Line 20 opens the contract, and carries two words you have not met. `is Context` says this contract builds on another one, taking its contents as if they were written here. That is the import from line 6 being used.

The other is `abstract`. Ana tries to deploy this file on its own. What happens?

One line. One address. That is the complete memory of a contract that thousands of protocols rely on, and it is worth pausing on how small that is.

`private` means other Solidity code cannot reach it directly, not even contracts that inherit from this one. It does not mean secret: every value a contract stores is readable by anyone querying the chain. The privacy is from code, never from people.

Three declarations, none of which does anything yet. The first two are errors: named failure types the contract can raise instead of a text message. Your previous contract simply stopped with nothing to say; this one can name the account it rejected.

The third is an event, the announcement written into the log for anything watching from outside. Declaring all three up front, before any function uses them, is ordinary style. When you meet a name later in a file, look upward: it was almost certainly introduced here.

The constructor: code that runs exactly once, while the contract is being deployed, and then never again. It takes the first owner as an argument rather than assuming it.

Line 39 checks for the zero address, an address nobody holds the keys to, and refuses it by raising one of the errors declared above. Note what it does not do: it never reads who is deploying. The deployer must say who the owner is, so the two need not be the same account.

Function first: a named piece of code that wraps around a function and runs before it, so the same check can be written once and applied anywhere. The name: a modifier. This one is called onlyOwner.

Its body is two lines, and the second is a bare underscore. Below it sits the check it delegates to. Tap each of the three highlighted lines to read what it does.

Two functions, and both carry `onlyOwner` after their visibility. That is the modifier being used: written once above, applied here by name, and the check runs before either body does.

One transfers ownership to a named address. The other transfers it to the zero address, deliberately. Ana calls the second one. What is she able to do afterwards?

Every line is lit. Two comments, a version, an import, a block of documentation, one variable, two errors, one event, one constructor, one modifier and four functions. Forty lines of code wearing sixty lines of paperwork.

Line 95 is where the three doors meet: an internal function that does the actual writing and announcing, so the logic exists once. One honest question before you go.

Two contracts now. One from 2015 that kept everything inside itself, one from today that is half documentation and points at another file on line 6. Between them they are the two shapes you will meet for the rest of your reading life.

The next checkpoint is the smallest real contract in the course, and it exists to answer one question: what does a contract actually remember?