at Once Everything

The board has moved down and now runs from line 49 to line 106. Lines 63 to 66 are a modifier, which you met in checkpoint five, and it takes a parameter, which you met in checkpoint ten. The registry's gate took a node. This one takes a role.

Line 64 hands that role to a name beginning with an underscore, and line 65 is the underscore on its own, where the body of whichever function carries this modifier drops in. Four lines, and you have read every one of these shapes before. Nothing on them is written.

`hasRole` on line 76 is public, view and virtual, and its body is a single line. Read line 77 from left to right. `_roles[role]` picks one record out of the mapping. `.hasRole[account]` then indexes the mapping sitting inside that record. Two lookups in one expression, and no `if` anywhere.

The field and the function share a name and are not the same thing. One is the table declared inside the struct on line 51. The other is the public reader declared on line 76, and the compiler tells them apart by what is written in front of each.

Line 70 is checkpoint thirteen turning up in production. A comparison against this contract's own interface id, an `||`, and `super.supportsInterface` on the right of it. You worked out what that shape answers before you had ever opened a file that used it in earnest.

Line 68 points at the inherited documentation rather than repeating it, the way checkpoint twelve did. Line 69 carries `override`, because ERC165 declared this function first and this line replaces it. Now answer the question you answered then, against the real line.

`_checkRole` is declared twice, on line 84 and on line 92, and checkpoint nineteen gave that its name. One name, told apart by the parameter list. The first takes a role on its own. The second takes a role and an address, and it is the one holding the actual work.

Line 85 is the entire body of the first. It calls the second, filling in the missing argument with `_msgSender()`, which is the single function Context contributed on line 6. The shorter declaration exists so that nothing calling it has to say who is calling.

Now put the pieces in order. A function is written with `onlyRole` and a role in its signature, and before its own body runs the call travels five lines. Every one of those five is lit on this board, and you have already read each of them on its own.

Nothing on the path writes anything. Three of the lines only carry a value along, one reads a single `bool` out of the record, and the last one stops the transaction. Tap each in turn and read what it adds to the question being asked.

Line 105 reads the other field of the record, `adminRole`, and hands it straight back. One reader per field, which is how the registry in checkpoint ten was arranged as well, except that this record has only two fields and so this file needs only two of these.

So every role names another role as its admin, and the naming lives inside the record. A role nobody has configured answers here with thirty two zeros, which is the constant on line 57, and that is the sentence you worked out six steps ago.

Lines 108 to 160 now. `grantRole` on line 120 and `revokeRole` on line 135 are one declaration written twice, and each ends with `onlyRole(getRoleAdmin(role))`. The argument handed to the modifier is not a constant. It is the reader from two steps ago, run against the role that just arrived.

Then the split from checkpoint twelve, exactly as it was there. Line 121 hands the work to `_grantRole` and line 136 to `_revokeRole`, and neither of these public functions touches the table itself. Three lines each, and one of the three is a brace.

Read line 154 against line 135 and something is missing. `renounceRole` ends at `public virtual`. No modifier, nothing at all between the parameter list and the opening brace, and it is the only function in the file that writes and is arranged that way.

What it has instead is lines 155 to 157, a comparison written into its own body. The second parameter is an address, and line 159 hands that same address on to `_revokeRole`. Work out what those three lines settle before you read any further.

The last board, lines 162 to 206. `_setRoleAdmin` is five lines and it writes the second field of one record. Line 168 reads the old value first, line 169 writes the new one into `_roles[role].adminRole`, and line 170 announces the two of them alongside the role they belong to.

This is the line that lets one role be the admin of another. Nothing anywhere pins an admin to the constant on line 57, so a contract built on this file may point a role's `adminRole` at whichever role it likes, and every role starts at zero until this runs.

`_grantRole` on line 180 is `internal virtual`, which is checkpoint eleven, and it returns a `bool` that none of the public writers above bothered to read. Line 181 asks whether the account already holds the role. Line 182 writes `true` into the record, line 183 announces it, line 184 hands back `true`.

Line 186 is the other half of the answer. If the account already held the role then nothing is written, nothing is announced, and `false` comes back instead. Granting twice costs one write rather than two, and this function says which of the two happened out loud.

`_revokeRole` on line 197 is line 180 with three things turned around. The `!` has gone from line 198, line 199 writes `false` where the other wrote `true`, and line 200 announces the opposite name. Everything else about the two, down to the `else` and the returned `bool`, is identical.

Look at what lines 183 and 200 pass as their third value: `_msgSender()` again, so each announcement carries who did it. Neither event is declared here. Both shapes live in IAccessControl, along with the `indexed` markers you met back in checkpoint three.

Every line of it, on one board, with the comments dimmed away. A struct, one mapping, one constant, one modifier, six public functions and five internal ones. That is roughly seventy lines of code sitting inside a file of two hundred and six, and you have now read all of them.

Not one of those lines was new. So be exact about what reading them settles for you, and just as exact about the one question this file cannot answer no matter how carefully anybody reads it.

This act opened with thirty eight lines you could not read without opening a second file. It closes with two hundred and six that needed nothing but what came in between: inheritance, interfaces, calls to strangers, raw calls, where an address lives, what a contract looks like as bytes, and choosing where to stop.

Nothing in this last file was new, and that was the whole exercise. A production contract is not a harder language. It is the same words, arranged by somebody who had read a great many of them. From here the files arrive cold, and nothing is dimmed for you.