What to Read Choosing

Four of the lit lines are two names, each written twice. `parseUint` on lines 159 and 171, `tryParseUint` on lines 182 and 192. You have seen this pairing in another file: one of them stops the transaction when the work cannot be done, the other hands you a bool and leaves the decision to you.

Line 173 is the revert inside the first. Line 197 returns `false` rather than stopping. The prefix on a name is doing as much work as the name, and the same pair repeats further down for signed integers, for hexadecimal, and for addresses.

Line 171 carries `pure`, and here is that word in its natural home. A `view` function may read stored values without writing them. A `pure` function may not even read them. Everything it works with arrives in the parentheses, and everything it produces leaves through the return.

That has one consequence worth the whole checkpoint. A pure function can be settled by reading it and nothing else. No other line of this file, no stored value, no call made earlier can change what lines 172 to 174 do with a given input.

A library holds no state, so lines 17 to 22 are `constant`, fixed when the file is compiled. Line 17 is sixteen characters, `0123456789abcdef`, and you will watch it get indexed shortly. Line 18 is twenty, the byte count of an address. Lines 19 to 22 belong to a function you are not opening.

Then three errors, declared once and thrown by name. Line 27 carries a value and a length, so a caller learns both numbers. Line 32 carries nothing, because a bad character has nothing useful to hand back. The one on line 27 is the one you are going to reach.

Three declarations on this board carry the same name. Line 72 takes a `uint256`. Line 81 takes a `uint256` and a `uint256`. Line 100 takes an `address`. Solidity allows that, and it chooses between them by the number and the types of the arguments written at the call site.

There is a fourth further down at line 131 taking a `bytes memory`, which you can note and leave closed. The name is not the function. When a call reaches a name declared four times, the argument list is the only thing deciding which body runs.

Line 100 is the shortest of the three. Its body is a single line: widen the address into a `uint256` by hand, and call a `toHexString` again, this time with a second argument. That second argument is `ADDRESS_LENGTH`, the constant you read on line 18 of the file, which is twenty.

So a call carrying one address lands here and immediately becomes a call carrying two arguments, one of which you never wrote. Work out which of the three declarations line 101 reaches, and what width it is asking that declaration for, before reading any further.

This is the function you picked, and from here you read every line of it. Line 81 takes a value and a length, returns a `string memory`, and is `pure`. Line 82 copies the value into a local, because the original is wanted again later and the loop is about to destroy this one.

Line 83 asks for a buffer of `2 * length + 2` bytes: two characters for every byte of output, plus two for the prefix. Lines 84 and 85 write that prefix immediately, a `0` and an `x`, and the rest of the buffer has nothing in it yet.

The loop is three lines and it runs from the back of the buffer toward the front. Line 86 starts `i` at the last position and brings it down, stopping while `i > 1` so the two prefix characters are never overwritten. Lines 87 and 88 do all of the actual work.

Line 87 picks one character out of the sixteen on line 17 of the file and writes it. Line 88 shifts the local value right by four bits. Tap each line and read what it is taking off the number, then you will run a real value through the three of them.

Call it with a value of 255 and a length of 1. Line 83 makes a buffer of four bytes. Lines 84 and 85 fill the first two with `0` and `x`. Line 86 starts `i` at three, and 255 is eight ones in binary, so its lowest four bits are 1111, which is fifteen.

Line 87 writes `HEX_DIGITS[15]`, an `f`, at position three. Line 88 leaves fifteen behind. The second pass writes another `f` at position two and leaves zero, `i` drops to one, and the loop ends. Line 93 hands back `0xff`. That is what reading a pure function completely gets you.

Once the loop ends, `localValue` holds whatever the shifting could not consume. If the buffer was wide enough the number reached zero and line 90 is false. If it was not, part of the number is still sitting there and has quietly gone nowhere, which is the one outcome this function refuses.

Line 91 reverts with the error declared on line 27, carrying the original value and the width you asked for. Call it with 256 and a length of 1 and that is what you get: two zero characters written, a one left over, and a stop.

Near the end of the file sits this. Line 513 is a declaration you can read without help: private, `pure`, takes a buffer and an offset, hands back a `bytes32`. Then line 515 opens an `assembly` block, and what is inside it is a different language with different rules.

You have met that shape before and you are not descending into it here. The comment on lines 507 to 512 says what the function is for, the declaration says what goes in and comes out, and that is enough to carry on elsewhere. Stopping on purpose is a reading skill.

Count what you have actually read. Three functions completely: lines 171 to 175, lines 81 to 94, and the three line one at 100 to 102. Seven more you have seen as a declaration and nothing else. The remaining twenty one in this file you have not looked at, and that is the right number.

That is about twenty lines of function body out of five hundred and thirty two, and they were the right twenty rather than a random twenty. Say precisely what reading them buys you, and just as precisely what it does not, before the checkpoint closes.

Two words did most of the work. `pure`, which says a function reads nothing outside its own arguments and is therefore the one kind of function you can finish reading. And a name declared more than once, where the argument list rather than the name decides which body runs.

The third thing is not a keyword. You chose what to read. Five hundred and thirty two lines, three functions opened, one stretch of a different language recognised and left alone, and an honest sentence at the end about what you now know.