The and the Arithmetic Clock

Here is the new word. Function first: a value any contract can read that holds the second at which the block containing this call was produced. The name: block.timestamp. It appears exactly twice in this file, on lines 98 and 106, and nowhere else.

It is a plain number, counting seconds since the first of January 1970, the same count most computers keep. No calendar, no timezone, no formatting. A contract cannot look at a clock on the wall. It can read the number stamped on the block it is running inside, and that is the lot.

Three `view` functions, all `public virtual`, all one line long. Two of them hand back an immutable value. The third, on line 77, stores nothing at all: it adds the other two together and gives you the result.

That is the shape of every time calculation in the file. A second-count plus a length of seconds is another second-count. Nothing converts, nothing formats, and nothing in here knows what a day is. The meaning is yours to supply; the type is a number.

Here is the calculation the whole contract exists to perform. Line 151 opens it: `internal`, so only this contract and anything inheriting it may call it; `view`, so it cannot write; and it takes a total allocation and a second to answer about.

Below it sit three branches and nothing else, and between them they cover every second that will ever exist: before the schedule, after it, and inside it. Tap each answer in turn.

Read it as a fraction. `timestamp - start()` is how many seconds have elapsed since the schedule began. `duration()` underneath is how many seconds it lasts in total. Put one over the other and you have how far through the schedule this second falls.

Multiply the allocation by the elapsed seconds, then divide by the duration, and out comes the allocation's share. Nowhere in that line is there a percentage, a rate, or a decimal point. It is three arithmetic operations on whole numbers, in that order.

Second new word, and this one is a property of the language rather than a keyword. Function first: division between whole numbers that discards whatever is left over instead of producing a fraction. The name: integer division, and dropping the remainder is called truncation.

Solidity has no decimal type. `uint256` on line 40 and `uint64` on line 42 hold whole numbers, and there is no third option anywhere in the file. So ten divided by three is three, and eleven divided by three is also three. The remainder is not rounded. It is dropped.

Take the smallest example that shows the effect. An allocation of ten whole units, a duration of three seconds, and a call that lands exactly one second after the start. Put those three numbers into line 157 and work through it in the order the brackets give you.

Multiplication first: ten times one is ten. Then the division by three. The line is not asking what a third of ten is. It is asking how many whole units fit into ten thirds, because a whole number is the only kind of answer it has room for.

Now the first and third branches read differently. They are not tidy early exits bolted on for neatness. They are the two places where the middle line's arithmetic would either be impossible or would leave something behind.

Before the start, `timestamp - start()` would need to be negative, and an unsigned number has no room for that. After the end, truncation would keep shaving units off a total that is already complete. Both ends are answered exactly, and neither one divides.

There is no list of dates in this contract and no array of instalments waiting to be ticked off. Line 137 works out the total allocation fresh on every call: whatever the contract still holds, plus whatever has already left. Line 116 is what keeps that second half honest.

And because the schedule is a function rather than a table, line 151 can be `virtual`. A contract inheriting this one may replace `_vestingSchedule` with a different curve and every other line in the file goes on working exactly as written.

Every line is lit. A licence, a pragma, five imports, a long comment block, two events, four state declarations, a constructor, a receive function, twelve functions and the closing braces. One hundred and sixty lines, and you have now read all of them.

And the behaviour of the whole contract was line 157. Everything else exists to hand that line an allocation and a second, to answer the two ends it does not cover, or to move the number it returns.

So here is the skill, plainly. Given a second, you can now compute what this contract will hand over, by hand, using lines 137 and 157 and the two values fixed at deployment. No part of that calculation is hidden from a reader.

Now be exact about what that settles and what it leaves open. The formula is fixed at deployment. The moment somebody chooses to ask it a question is not, and neither is the allocation it will be asked about.

Two new words, and only one of them was a keyword. `block.timestamp`, the single clock a contract has and a plain count of seconds. And integer division, which answers in whole units and quietly drops whatever will not fit into one.

There is one line we walked straight past. Line 118, where the ether actually leaves, hands that job to a library instead of doing it inline. That idiom turns up in almost every contract you will read, and it is waiting for you later in this act.