A Contract in Bytes

Line 32 declares `clone`, taking one address and returning one. Its entire body is line 33, which calls `clone` again with a second argument of zero. Line 47 declares that second `clone`: same name, two parameters. The compiler picks between them by what you pass.

A function handing its work to another function is old news by now. The reuse of the name is not. Two functions may share a name when their parameter lists differ, and line 33 is how a file gives one of them a default. Line 26 claims the create opcode should never revert.

Take the comments out of the two-argument `clone` and four lines are Solidity. Lines 48 to 50 check this contract holds enough balance to send onward, and throw `Errors.InsufficientBalance` carrying both numbers when it does not. Then line 51 opens `assembly`, the same brace you met in checkpoint sixteen.

The `memory-safe` label is a promise to the compiler about which memory this block touches. Everything from line 51 to line 58 is Yul, and it is three lines long. Two of them are `mstore`, which you have read before. The interesting part is what gets stored.

Line 54 writes one word into memory at offset zero. Most of that line is a literal: `0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000`. Count the pairs of hex digits and you get twenty three bytes, the last three of them zero.

The comment above says those zeros are a hole, and that the first three bytes of `implementation` are being packed into it. So the zeros are not padding and the value is not a quantity. Say what you think this literal is before you read the next line.

Line 56 writes the second word, at offset `0x20`. It shifts `implementation` left by a hundred and twenty bits, which is fifteen bytes, and ors it against another literal of exactly fifteen bytes. Seventeen bytes of address land in front, fifteen bytes of code behind them.

Three bytes of the address went into the tail of line 54, seventeen go into the head of line 56, and twenty bytes is an address. The address is not kept anywhere. It is spelled out inside the instructions, split across two words only because that is where the boundary happened to fall.

Line 57 is `create`. Its three arguments are how much native currency to send, where the bytes begin in memory, and how many of them there are. Offset nine, because a twenty three byte literal sits at the right hand end of a thirty two byte word, and thirty two take away twenty three is nine.

Length `0x37` is fifty five: twenty three from the first word plus thirty two from the second. `create` deploys those bytes and hands back the address it put them at. When it cannot, it hands back zero, and lines 59 to 61 turn that zero into a revert.

Read the block as one thing. Fifty five bytes get assembled in memory: ten bytes of preamble, ten more, twenty of address, fifteen at the end. `create` deploys all fifty five, and the preamble's only job is to hand back the forty five bytes behind it as the new contract's code.

Forty five bytes. No function names, no table of selectors, no variables, nothing that was ever compiled. Whatever a call to that address carries, those forty five bytes do exactly one thing with it, and you read that one thing three checkpoints ago.

Lines 90 to 109 are the two-argument `clone` again, with a salt added. The comment says why: `create2` takes that salt, and the same implementation with the same salt cannot be deployed twice, because both would land at the same address and only one contract fits there.

Everything between those braces is work you have already read. Tap the three Yul lines and check them against lines 54, 56 and 57, character by character. The distance between deploying anywhere and deploying at an address of your choosing is smaller than it looks.

Line 114 takes an implementation, a salt and a deployer, and returns an address. Line 118 marks it `pure`: it reads no storage, makes no call, touches nothing outside its own arguments. Line 134 is the same function one parameter shorter, filling in `address(this)` on line 138.

So an address comes out of arithmetic on three values. Nothing has been deployed, nothing sits at the answer, and line 112 is careful to say computes rather than finds. You can hold the address of a contract before there is a contract to hold the address of.

The body assembles the clone one `mstore` at a time, at a pointer taken on line 120. Line 124 is line 54's literal with the three zero bytes gone, because here the address gets an `mstore` of its own on line 123. Line 126 then hashes fifty five bytes of it.

That hash is how `create2` settles on an address: from the deployer written on line 121, the salt on line 125, and a hash of the exact code being deployed. Line 127 hashes all of that and keeps the low twenty bytes. Change one byte of the code and the address moves.

Lines 141 to 267 are a second family: clones carrying extra arguments, and a reader that fetches those arguments back off a deployed one. Not this checkpoint's business. But line 283 finally throws the error declared on line 21, and the helper beneath it builds a clone's code in ordinary Solidity.

Lines 288 and 290 are hex literals joined by `abi.encodePacked`, and they are the same characters you read inside the assembly. Line 277 says the proxy code is forty five bytes, out loud. Same bytes, two spellings. Now say what this file can and cannot tell you.

Seventeen checkpoints of source, and this is the first file that shows you the other side of the compiler. Forty five bytes, assembled in two words of memory, handed to an instruction that returns an address. No `contract` keyword anywhere near the thing that got deployed.

You can now read a deployed clone by eye. Find `363d3d373d3d3d363d73`, take the twenty bytes after it, and that is the address every call goes to. Source is written for people to read. Bytes are what the machine actually runs.