The Files It Around

Seventeen lines, and this is the entire library that line 12 of the pair attached. A pinned pragma, one comment, and three functions. `add`, `sub` and `mul`, each `internal pure`, each returning a named `z`, each with a body of exactly one `require`.

That is the whole of the thing you were told about. Not a framework and not a pattern. Seventeen lines in a file next to the one that uses it, and every `.add` in the pair resolves to line 6 of this file.

Line 7 is worth reading slowly, because the assignment sits inside the comparison. `(z = x + y)` works out the sum and writes it to the named return in one move, and the value of that whole parenthesised expression is the sum itself, which `>= x` then tests.

So the question line 7 asks is: is the total at least as large as one of its parts? Adding a number that cannot be negative can only move you up. If the result came out below `x`, the sum passed the top of a `uint` and came round, and the call stops here.

Line 11 is the mirror of line 7. A difference should be no larger than the number you began with, so if it is larger the subtraction went below zero and came round from the top. One operator changed, one comparison flipped, everything else the same.

Line 15 divides back. Multiply, then divide by the same operand, and if you do not land on `x` again the product did not fit. The `y == 0` in front of it is there because that division would not be legal otherwise. Three functions, three checks, seventeen lines.

Math.sol is twenty three lines and holds two functions. Line 7 is all of the first: a conditional expression handing back whichever of the two numbers is smaller. The pair calls it once, at UniswapV2Pair.sol line 123, to pick the lesser of two ratios.

The second function runs from line 11 to line 22 and answers something checkpoint twenty two could only point at. Line 120 of the pair works out the first liquidity ever minted as `Math.sqrt(amount0.mul(amount1))`. This is where that square root is actually computed.

The comment on line 10 names the method and links the article that describes it. Solidity has no square root operator, so line 11 has to produce one by repeating an operation, and lines 13 to 18 are the whole of that repetition.

Two values, closing on each other. Line 13 sets one from `y` itself, line 14 sets the other to roughly half of `y`, and line 15 keeps the loop going while the second is still below the first. Tap the four lines in the order they run.

Line 12 is the gate. Only a `y` above three reaches the loop at all. Lines 19 and 20 catch one, two and three and answer one, which is the floor of the root of each of them. A `y` of zero matches neither branch and runs nothing.

And nothing in this file ever returns. `z` is named in the signature on line 11, so a `z` nobody wrote is zero, which is the right answer for zero. That is the same naming you read in `getReserves` at UniswapV2Pair.sol line 38.

Twenty lines, and the first six are comment. A binary fixed point number, range zero up to two to the one hundred and twelve minus one, resolution one over two to the one hundred and twelve. Line 9 is the only constant here: `Q112`, held as a `uint224`.

This is how a contract stores a fraction without a decimal point. You keep the numerator multiplied by a fixed power of two, and you remember the scale. Nothing has been rounded away at the point of storage, because nothing has been divided yet.

Line 13 is the encoding. Take a `uint112`, widen it to a `uint224`, multiply by `Q112`. The comment says it never overflows and the widths say why: a hundred and twelve bits of value, shifted up by a hundred and twelve places, is two hundred and twenty four.

Now put a real pair of numbers through it. UniswapV2Pair.sol line 79 reads `UQ112x112.encode(_reserve1).uqdiv(_reserve0)`, so one reserve becomes the numerator and the other the divisor. Take three and two, and work out what comes back.

Line 18 is one division and one cast. The numerator arrives already scaled, and the divisor is a plain `uint112` widened to match, so the scale passes through the division untouched and what comes out is still a UQ112x112. The comment on line 16 says precisely that.

Which is where the low bits survive. Divide three by two as plain integers and the half is gone, as it was in checkpoint seven. Divide three times the scale by two and the half is still there, sitting in the bits underneath.

Five lines, one of them blank. An interface with a single function in it, and that function is the whole of what UniswapV2Pair.sol line 172 calls. The address it calls is `to`, which is the recipient the caller named in the arguments to `swap` on line 159.

Now read line 1 against the other four files. They pin `=0.5.16`. This one says `>=0.5.0`, because it is written to be imported into somebody else's contract. An interface is a shape for others to match, so it stays loose about the compiler.

Forty nine lines, and the first thing to find is line 7. Checkpoint twenty two watched `_mintFee` call out to the factory at UniswapV2Pair.sol line 90 and ask it for `feeTo`. Here is the answer: a stored address, written only by lines 40 to 43.

Lines 10 and 11 are the two indexes. A mapping of a mapping, marked `public`, so reading it takes two addresses and gives back one. Then an array of every pair ever made, with its length exposed on lines 19 and 20.

Fifteen lines, and this is where every pair that has ever traded came from. Line 24 refuses two of the same. Line 25 sorts. Lines 28 and 29 build the creation code and a salt. Line 31 drops into assembly for one opcode, which is checkpoint eighteen.

Then three writes and an event. Line 33 hands the sorted tokens to the new contract, which is the `initialize` that UniswapV2Pair.sol line 66 accepts from nobody but its factory. Walk the whole thing with the arguments given in the awkward order.

Back to the import block with four of the names opened and the factory read. About a hundred and fourteen lines, four of the five files under twenty five. What made them look closed was that they were named rather than shown.

So be exact about what those files bought you, and equally exact about what is still behind a name on this list. Three of these seven imports have never been opened, and one line of the pair calls code that is in no file here at all.

Five files, about a hundred and fourteen lines, and four of them shorter than the contract you read in week one. What made them look closed was that they were named rather than shown, and every one of those names sat on a line you had already read.

The method is four moves and it repeats. A name. The import line. That file. Then the one function you came for, with the rest of it left shut. Checkpoint nineteen did that within a file, and this is the same choosing, made across five of them.