The Promise

Events, which you know: the announcements written into the log for anything watching from outside. `indexed` marks the fields a watcher can filter on, and here it marks the addresses in both, so a wallet can ask for only the lines that mention it.

Now notice what is odd. No function in this file has a body, so nothing here can ever emit either event. It declares the shape of the announcement and leaves the announcing to somebody else.

The first function, and the shortest one you have read anywhere. A name, no parameters, `external`, `view`, and a `uint256` coming back. Then a semicolon, sitting exactly where the last six contracts you read opened a brace.

Everything in that line is vocabulary you already have. The punctuation at the end is not. Ana reads line 27 and asks what the semicolon is doing there. Answer before the file tells you.

Three of the six carry `view`, so any contract implementing them is promising that these three never write anything. How much exists in total, how much one account holds, and how much one account has allowed another to spend on its behalf.

That last one takes two addresses because permission here is a pair, an owner and a spender. You have already read that exact pair as a nested mapping, twice. The interface fixes the shape of the question; both tokens picked the same storage to answer it with.

The other three change something, and each ends `returns (bool)`. Move my tokens to an address. Let somebody else move a quantity of mine. Move tokens that somebody already allowed you to move, which is why line 78 names a `from` as well as a `to`.

The documentation above each one says the boolean indicates whether the operation succeeded. The declaration itself cannot enforce that reading. A bool is a bool, and what it means here lives entirely in the sentence above the line.

Every function here is `external`, and that is not a matter of taste. An interface describes a contract as seen from the outside, so a declaration that only inside callers could reach would be describing nothing anybody could use.

You met `external` as one visibility among four, chosen by an author. Tap the three highlighted lines to see what it is doing in a file that has no bodies to be visible from.

The largest single thing in the file is a comment, and it sits above one declaration. The braces around `{approve}` and `{transferFrom}` are NatSpec cross references, so tooling turns each into a link to that entry rather than treating it as plain text.

Here is why a file this small is mostly words. A declaration can fix a shape and absolutely nothing else. Every expectation about what these six functions ought to mean has nowhere to live except the prose sitting above them.

Count what is behind you. WETH9 from 2015, Uniswap V2's token, and Solmate's ERC20. Every one of the three has a transfer, an approve, a transferFrom, a balanceOf, an allowance, a totalSupply, and these same two events.

WETH9 is the interesting one. It was written before this file existed in its present form, and it imports nothing whatsoever. Hold its lines against these six declarations and say what you expect to find.

Take line 41 by itself. It settles the name, that two arguments go in, that the first is an address and the second a number, that callers outside may use it, and that a bool comes back. That is the complete list of what it settles.

It does not settle how much arrives, or what the bool holds when nothing moved, or whether anything moved at all. Two contracts can both satisfy this file and behave nothing alike. An interface constrains shape, and never behaviour.

So what is it actually for. You hold the address of a contract you did not write and cannot open. Name this interface, hand it that address, and the compiler now knows precisely what a call to `transfer` has to look like on its way out.

That is the trick behind one contract using another, and the third act takes it apart properly. For now, notice the trade. You may call anything that answers to these six lines, and you are promised nothing about what happens next.

Every line is lit. Two comments, a version, four documentation blocks, one interface, two events and six declarations. Ten lines of code carrying sixty nine lines of paperwork, and between them they govern most of the tokens on Ethereum.

You can now read it, name its six functions, and recognise them on sight in the next token you open. One honest question before you go, about what that recognition is really worth.

Three tokens behind you, one interface in front of you, and the thing all three have in common turns out to be a list you can read in a minute. The file promises nothing about behaviour, and it never pretended otherwise.

What it gives you instead is a way to talk to code you did not write. Holding an address and knowing what to send it is where contracts using contracts begins, and that is the direction the rest of this is heading.