What It Can Do

Function first: a marker on a function that may read the contract's state but may never write it. The name: view. Two of the nine carry it, on lines 162 and 166, and the compiler holds them to it.

That is a strong thing to learn from one word. Calling either of these cannot change a single stored value. And the absence is just as informative: the other six carry no `view`, so any of them may write.

Every single function carries one more word. Function first: a marker saying a contract that inherits this one is allowed to replace this function with its own version. The name: virtual.

Now look up at line 8, which you have been reading past. `abstract contract ERC20`. An abstract contract cannot be deployed by itself. Line 8 and the eight `virtual` markers are saying the same thing twice.

Three signatures end with `returns (bool)`: approve, transfer and transferFrom. Look at the last line of each of those three bodies and you find `return true`, on lines 73, 87 and 109. The signature was not a suggestion.

Why a bool that is always true? Because the ERC20 standard says these three hand one back, and code written against the standard expects to read one. Line 124 shows the alternative: `permit` declares no return at all.

Two signatures are too long for one line. `transferFrom` takes three parameters and `permit` takes seven, so each parameter gets a line of its own and the closing bracket carries everything that would have followed it.

Nothing new is happening here. Read lines 90 to 94 as a single line and you get name, parameters, visibility, virtual, returns, in exactly the order you read on line 68. Wrapping is a layout choice, not a different kind of function.

Now read a body and mark the signature's homework. Line 183 says: two parameters, a recipient and an amount; `internal`, so nobody outside calls it; no `returns`, so it hands nothing back to whoever did.

Everything below follows from those three facts, and there are no surprises in it. Tap the three lines that do the work.

One detour upward, because a new word is sitting in the state block. Function first: a marker for a value written once while the contract is being deployed and never again afterwards. The name: immutable.

Three of them here, on lines 25, 41 and 43, and all three are assigned in the constructor. Last lesson you met `constant`, fixed when the contract is compiled. These two words are not interchangeable.

Every line is lit. Two events, nine state declarations, a constructor, five public functions, three internal ones, and roughly forty lines of comment holding them apart. Twice the length of anything you have read, and you have now read it.

But you could have described most of it from step two. Nine lines named every function, said which five outsiders could call, promised which two never write, and stated what each one hands back.

So here is the skill, plainly. Opening an unfamiliar contract, find the signatures first. They are near the top of each function, there are rarely more than a couple of dozen, and each one pays back four facts for one line of reading.

Now be exact about what a signature settles and what it leaves open.

Four contracts in, and a habit has formed. Read the state block to learn what the contract remembers. Read the signatures to learn what it can be asked to do. Both live near the top, and both are short.

The next checkpoint goes inside a body. There is a word waiting for you in this constructor, on lines 52 and 53: `memory`, sitting on a parameter, saying where a value lives for the length of one call.