When It Says No

Modifiers, the construction behind Ownable's `onlyOwner`: a named piece of code that wraps a function and runs before it. There are two here and they are mirror images. One admits a call only while the contract is running, the other only while it is paused.

The names are doing deliberate work. A function marked `whenNotPaused` reads as a sentence at the place it is used, which is most of the reason to give a gate a name at all. Tap the three highlighted lines.

One public function in the whole file, and it does nothing but hand back the bit. `view` is a promise that it writes no state, so anyone can ask this contract whether it is paused and the asking changes nothing about it.

`virtual` is the other word on the line, and it means a contract inheriting this file is allowed to replace this function with its own. Hold on to that, because the next two functions ask the question through this function rather than reading the variable themselves.

Here is where a refusal actually happens, and the shape is three lines: if a condition holds, raise a named error. No message, no string, nothing hidden. `if (paused()) revert EnforcedPause();` is the entire thought, and the file does it twice.

Notice that both call `paused()` rather than reading `_paused` directly. That is what the virtual on line 67 was for: a contract that replaces the getter changes what both of these checks see, without either of these lines being touched.

Step back and count. In WETH9 you read `require(balanceOf[msg.sender] >= wad);`, a bare check with nothing to say when it fails. In the Uniswap token you read the same construction carrying a string, `'UniswapV2: EXPIRED'`, which arrives back readable.

In Ownable you read `revert OwnableUnauthorizedAccount(...)`, a named failure carrying the account that caused it. Here you read that same construction with empty parentheses. Four styles, and they differ in one thing only: how much the caller learns.

One word on one line, and it is the most important word in the lesson. `revert` does not halt a call where it stands and keep whatever happened up to that point. It abandons the whole call and puts the contract back exactly as it was before the call began.

That is why a refusal can be read as simply a refusal. There is no half finished state to reason about, no balance moved without its matching one. Before the reveal: what is left behind afterwards?

The functions that move the bit, and each is two lines: assign, then announce. `_pause` writes `true` and emits Paused. `_unpause` writes `false` and emits Unpaused. The argument to both is `_msgSender()`, the tidier way of naming the caller that Context provides.

Now look at what each one wears. `_pause` carries `whenNotPaused`, so pausing an already paused contract is refused. `_unpause` carries `whenPaused`. That is where ExpectedPause is finally raised, and why the file needed two errors rather than one.

Both switches are `internal`. You met the word in the Uniswap token: reachable by this contract and by anything inheriting it, and by nobody else. No account anywhere can call `_pause` directly, whoever they are and whatever they hold.

So this file hands a contract the ability to pause and deliberately declines to say who may use it. An inheriting contract writes its own public function, puts whatever gate it likes on that, and calls `_pause` inside it. Two files, two separate decisions.

Every line. Two comments, a version, an import, a page of documentation, one boolean, two events, two errors, two gates, one public getter, two checks and two switches. One hundred and twelve lines, of which about thirty are code.

Five contracts read now, and this is the first one whose whole subject is what happens when the answer is no. One honest question before you go.

Look at what a contract file is to you now. A licence and a version, a state block you read first, functions carrying visibility and gates, events for the outside, and a refusal that undoes rather than stops. You read all of that today unaided.

Act one was the whole shape at speed. Act two goes back over the same ground far more slowly, one word at a time, beginning with the types that every value in every contract you have read has quietly been.