Buy in.
Sell slowly.

1// LaunchToken.sol — the sell-vesting functions, copied without changes from the verified token contract.
2//
3//   - every buy is recorded per wallet with the block time it arrived (one lot per buy)
4//   - each lot unlocks 5% every 5 minutes (20 tranches, fully unlocked 100 minutes after that buy)
5//   - anything leaving a wallet must come out of the unlocked part, or the transfer reverts
6
7/// @notice Tokens `a` cannot move yet. Each lot unlocks 1 / vestSteps per step, counted from the exact time the
8///         lot arrived, so the first tranche is sellable exactly one step after the buy.
9function lockedBalanceOf(address a) public view returns (uint256 locked) {
10    if (vestSteps == 0 || vestExempt[a]) return 0;
11    Lot[] storage lots = _lots[a];
12    for (uint256 i = _lotHead[a]; i < lots.length; ++i) {
13        (, uint256 lockedAmt) = _lotState(lots[i]);
14        locked += lockedAmt;
15    }
16}
17
18/// @notice What `a` can sell or send right now.
19function unlockedBalanceOf(address a) external view returns (uint256) {
20    uint256 bal = balanceOf(a);
21    uint256 locked = lockedBalanceOf(a);
22    return bal > locked ? bal - locked : 0;
23}
24
25/// @dev A lot's amount and how much of it is still locked (0 once fully vested). Rounded up: a wei never unlocks early.
26function _lotState(Lot storage l) private view returns (uint256 amount, uint256 lockedAmt) {
27    uint256 steps = vestSteps;
28    uint256 elapsed = (block.timestamp - l.start) / vestStepSeconds;
29    amount = l.amount;
30    if (elapsed < steps) lockedAmt = (amount * (steps - elapsed) + steps - 1) / steps;
31}
32
33function _requireUnlocked(address from, uint256 value) private {
34    _prune(from);
35    uint256 locked = lockedBalanceOf(from);
36    if (locked == 0) return;
37    uint256 bal = balanceOf(from);
38    uint256 free = bal > locked ? bal - locked : 0;
39    if (value > free) revert TokensStillVesting(free, value);
40}
41
42/// @dev Stamp a purchase with the block time. Past MAX_LIVE_LOTS live lots the buy merges into the newest lot with
43///      an amount-weighted start: dust cannot move a real purchase's clock and a large buy cannot borrow an older
44///      clock, since the weighted start sits between the two and total unlocked value is preserved.
45function _recordLot(address to, uint256 value) private {
46    if (value == 0) return;
47    (Lot[] storage lots, uint256 head) = _prune(to);
48    if (lots.length - head >= MAX_LIVE_LOTS) {
49        Lot storage last = lots[lots.length - 1];
50        uint256 total = uint256(last.amount) + value;
51        uint64 start = uint64((uint256(last.start) * last.amount + block.timestamp * value) / total);
52        last.start = start;
53        last.amount = uint192(total);
54        emit VestingLot(to, start, value);
55    } else {
56        lots.push(Lot({start: uint64(block.timestamp), amount: uint192(value)}));
57        emit VestingLot(to, uint64(block.timestamp), value);
58    }
59}
60
61/// @dev Every transfer, sell and send goes through here.
62function _update(address from, address to, uint256 value) internal override {
63    if (vestSteps != 0) {
64        // Whatever leaves a non-exempt address must be unlocked; whatever a non-exempt address receives from
65        // exempt plumbing (a buy) starts a lot. Mints and exempt-to-exempt moves are untouched.
66        if (from != address(0) && !vestExempt[from]) _requireUnlocked(from, value);
67        super._update(from, to, value);
68        if (to != address(0) && !vestExempt[to] && vestExempt[from]) _recordLot(to, value);
69        return;
70    }
71    super._update(from, to, value);
72}