What It Remembers

Now the opposite. These three have no `constant`, so they live in storage and can change. The two mappings should feel familiar: a balance table and a nested allowance table, exactly the shape you read in WETH9.

Line 12 is the interesting one. WETH9 never stored a total supply, it returned its own ETH balance and let that be the answer. This contract keeps a number and updates it by hand. Hold that difference, we will come back to it.

Four more declarations, and two of them are `bytes32`, a fixed lump of thirty two bytes, which is exactly the size of a hash. `PERMIT_TYPEHASH` on line 18 is marked constant. `DOMAIN_SEPARATOR` on line 16 is not, and is assigned in the constructor instead.

Both are hashes, both are decided once and never change afterwards. So why can only one of them be constant?

Two events, and you have met both. Approval and Transfer are declared by the ERC20 standard, which is why your wallet can show activity for a token it has never heard of: it knows the shape of the announcement even when it knows nothing about the contract.

Compare with WETH9, which had these two and added Deposit and Withdrawal of its own. This contract has no equivalent, because it wraps nothing.

The constructor, and it is doing one job: building the value line 16 could not hold as a constant. Lines 29 to 37 hash together the token name, a version, the chain id, and the contract's own address.

Lines 26 to 28 are honest new territory. assembly is a lower level language you can drop into from Solidity, and here it does one thing: read the chain id. Three lines, one value, and the vocabulary for it comes much later. Recognising it is enough for now.

Four functions nobody outside can call. Two are `internal`, reachable by this contract and anything inheriting it. Two are `private`, reachable only here. That is the distinction in one screen.

Between them they are every way a balance changes. Notice `.add` and `.sub`: that is the SafeMath library from line 4, doing by hand what a modern compiler does for you. Tap the three lines that move numbers.

Three external functions, and each is a thin wrapper: check nothing, hand the work to a private helper, return true. The pattern from the last lesson again, logic written once and reached through a door.

Line 74 should raise an eyebrow, because you have seen it before. The same `uint(-1)` idiom from WETH9, meaning the largest number the type can hold, used the same way: an allowance set to the maximum is never reduced.

The last function, and the reason DOMAIN_SEPARATOR and PERMIT_TYPEHASH exist. It lets an approval be granted by a signature rather than by a transaction, which is why the file has been carrying two hashes since line 16.

Be honest about what you can read here. The shape is clear: check a deadline, build a digest from the stored hashes, recover an address from a signature, require it to match, then approve. The cryptography underneath is vocabulary from a later act, and recognising the shape is the correct amount of understanding for today.

Every line is lit. Three constants, three storage variables, two more hashes, two events, a constructor with a detour into assembly, four helpers, three doors, and one signature function.

Now the difference worth carrying away. Both tokens you have read answer the question how many exist, and they answer it in completely different ways.

Three contracts in, here is the claim this lesson has been building toward. The state block of a contract, those nine lines, is its entire world model. Anything not in it, the contract cannot know and cannot act on.

So how far does reading the state alone actually get you?

Three contracts, and in each one the state block was short, near the top, and told you more per line than anything below it. Read it first, every time.

Now the other half. The next checkpoint is about what a function tells you before you read a word of its body.