// SPDX-License-Identifier: MIT pragma solidity ^0.8.30; /* MUSICAL CHAIRS / CHAIR A seat on an exchange used to be a thing you actually bought. A Chair in Washington still moves the whole tape by clearing his throat. And the oldest party game in the world is still the most honest chart anyone ever drew: the music plays, everybody circles, and the only question that matters is whether you are still standing. The pitch of this whole platform was a seat for everyone. The chain took that literally and never switched the music off, so for the first time the round does not end at four o'clock. The chairs just keep moving. The room is built the same way the game is: nothing extra in it. Ten billion seats are poured once, into the deployer, and after that no hand can add a chair, take one away, or decide who is allowed to sit. Written lean on purpose. Balances and allowances are the only storage this file owns, every move touches the fewest slots it can, and neither hot path makes an internal call. Approximate figures with the optimizer on, for orientation only - real numbers depend on the network and the state: transfer to an address that already holds ....... ~34k gas transfer to an address holding nothing yet ...... ~51k gas approve, first time / overwrite ................. ~46k / ~29k gas transferFrom .................................... ~40k - 60k gas */ /// @title Musical Chairs /// @notice Fixed-supply ERC-20 token. Ten billion seats, no operator, no surprises. /// @dev Single self-contained contract: no imports, no inheritance, no libraries. /// Metadata and supply are compile-time constants, so name(), symbol(), /// decimals() and totalSupply() never read storage at all. Every unchecked /// block sits directly under the comparison that proves it safe. contract MusicalChairs { string public constant name = "Musical Chairs"; string public constant symbol = "CHAIR"; uint8 public constant decimals = 18; /// @notice Ten billion seats, fixed forever. Constant, so this getter costs no SLOAD. uint256 public constant totalSupply = 10_000_000_000 * 1e18; /// @notice Seats currently held by an address. mapping(address => uint256) public balanceOf; /// @notice Seats a holder has agreed to let a spender take. mapping(address => mapping(address => uint256)) public allowance; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed holder, address indexed spender, uint256 value); /// @notice address(0) is not a seat. It cannot hold, receive or be approved. error NoSeat(); /// @notice Someone tried to stand up with more than they were sitting on. error NotSeated(uint256 held, uint256 wanted); /// @notice A spender reached for more than was ever saved for them. error NotSaved(uint256 saved, uint256 wanted); /// @notice Fills every seat in the room in one write, then the music starts. constructor() { balanceOf[msg.sender] = totalSupply; emit Transfer(address(0), msg.sender, totalSupply); } /// @notice Moves seats from the caller to another address. /// @return True on success. Failures revert; this never returns false. function transfer(address to, uint256 amount) external returns (bool) { if (to == address(0)) revert NoSeat(); uint256 held = balanceOf[msg.sender]; // one SLOAD, reused below if (held < amount) revert NotSeated(held, amount); unchecked { balanceOf[msg.sender] = held - amount; // held >= amount, checked above balanceOf[to] += amount; // every seat total is capped by totalSupply } emit Transfer(msg.sender, to, amount); return true; } /// @notice Saves a seat: lets a spender move up to `amount` on the caller's behalf. /// @dev Overwrites the previous figure rather than adding to it, the way ERC-20 expects. function approve(address spender, uint256 amount) external returns (bool) { if (spender == address(0)) revert NoSeat(); allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } /// @notice Takes a seat that was saved for the caller and moves it on. /// @dev The saved figure is always spent for real. There is no shortcut here for a /// maximum value, and no second Approval event is emitted for the decrease - /// only an explicit approve() call speaks, which keeps this path cheaper. function transferFrom(address from, address to, uint256 amount) external returns (bool) { if (from == address(0) || to == address(0)) revert NoSeat(); uint256 saved = allowance[from][msg.sender]; // one SLOAD if (saved < amount) revert NotSaved(saved, amount); uint256 held = balanceOf[from]; // one SLOAD if (held < amount) revert NotSeated(held, amount); unchecked { allowance[from][msg.sender] = saved - amount; balanceOf[from] = held - amount; balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } // Nothing else lives in this room. No hand on the stereo, no seat behind the // curtain, no rule that treats one address differently from another. The music // is on, and it is not this file's job to stop it. }