The Registry

Lines 17 to 21 are a modifier, the thing you met in act one: a named block of checks, written once, then attached to a function by name. This one takes a parameter of its own, and the parameter is a node.

Line 18 is the sentence to slow down on. It reads the owner out of the very record the caller is asking to change. Line 19 then requires that the caller is that address, and the underscore on line 20 is where the guarded function's own body drops in.

Line 19 holds two clauses joined by `||`. The first compares the caller against the record's owner. The second reaches into line 14's nested table as `operators[owner][msg.sender]`, asking whether that owner has already said yes to this caller in general.

Line 116 is the only place that table is ever written, and its outer key is `msg.sender` itself. A caller can only ever speak for their own records, which is why the function takes no node at all and needs nothing checked before it writes.

The constructor is three lines long and writes one field of one record. The node is `0x0`, thirty two bytes of nothing, and its owner becomes whoever deployed the contract. At this moment nothing else in storage has been written.

Every other record in the registry descends from that one. Line 13's mapping answers with a zero-filled `Record` for any key never written, so a node nobody has claimed reads back as the zero address in all three fields. The next step is how a record gets made at all.

Here is how the tree grows. The function takes a parent node and a label, both `bytes32`, and the modifier on line 79 is checked against the parent. The caller has to own the parent record, because the child record does not exist yet.

Three lines then do all of the work. The owner of one record decides the owner of the records underneath it, and keeping that arrangement is the whole reason this contract exists. Tap them.

Two more functions, and they are very nearly the same function written twice. Each takes a node and one value. Each carries `authorised(node)`, on lines 92 and 103. Each writes exactly one field of the record, named directly, on lines 94 and 105.

Neither one reads the other fields or touches them. A record is three independent slots under a single key, so changing the resolver leaves the owner and the `ttl` exactly where they were, and the same holds in the other direction.

Five `emit` lines sit in this file and not one `event` declaration. Line 3 imports another file and line 6 inherits from it, so the shapes come from there. What is worth reading here is which name the file puts with which write.

`Transfer` on line 68 for an owner. `NewOwner` on line 82 for a child. `NewResolver` on 93, `NewTTL` on 104, `ApprovalForAll` on 117. Every field carries its own announcement, matching the field-at-a-time way the setters write.

Lines 39 and 40 are an entire function body: `setRecord` does nothing itself, it calls the two smaller setters in turn. Lines 56 and 57 do the same for a child, passing the key that line 80 has just made straight into the second of those calls.

The internal helper at the foot of the file is where the two fields actually land, and each write sits behind an `if`. Line 179 compares the new resolver against the stored one, writing and announcing only when they differ. Line 184 asks the same of the `ttl`.

Five view functions, and between them they read every field there is. Line 140 returns the resolver, line 147 the `ttl`, line 167 the operator flag. Line 156 is the neat one: a record exists when its owner is not the zero address, because nothing else was ever written into it.

Line 126 reads the owner and then lines 127 to 129 do something extra. If a record's owner is the registry itself, the reader answers with the zero address instead, so one particular stored value reads back to the outside as no owner at all.

Every line is lit. A struct, two mappings, one modifier, a three-line constructor, seven functions that write and five that only read, plus two internal helpers underneath them. Not one number is added up anywhere in the whole file.

And a name in it is only ever thirty two bytes. Now be exact about what a mapping to a record settles for you, and about what it quietly leaves open.

A token's ledger answers one question: how much. A registry answers several at once, because its value type is a record rather than a number, and the three fields under a single key are read and written one at a time.

The vocabulary did not change once. A struct, a mapping, a modifier, events, a constructor, and words you already had before you opened it. Only the value type moved, and everything the contract is for moved along with it.