broke

1Why no liquidity pool?

Traditional token launches split into two failure-prone steps: mint a supply, then convince someone to seed a liquidity pool against it. Whoever controls that pool — team, VC, or a rug-pullable multisig — controls the token's fate.

broke removes that step entirely. The Uniswap v4 pool that trades broke against ETH is initialized with zero liquidity, forever. The hook's beforeAddLiquidity callback reverts unconditionally — nobody can ever add a concentrated-liquidity position to this pool, not the deployer, not a whale, not the hook itself. Instead, the hook intercepts every swap and settles it directly: buys mint new supply, sells burn existing supply. The bonding curve formula (Section 3) is the only price mechanism that has ever existed for this token.

2Architecture

Three contracts, three jobs:

None of the three has an owner, a pause switch, or a proxy pattern. What's deployed is what runs, permanently.

3The curve

broke follows a bounded exponential curve. Let K = 21,000,000 be the asymptotic supply cap (total supply approaches but never reaches this number), S = 500 ETH be the curve's scale factor (roughly the cumulative ETH spent for the curve to mint about 63%, i.e. 1 − 1/e, of its way toward the cap), and e be the cumulative ETH that has flowed into the curve, net of sells.

Forward curve — how much supply exists after e ETH has been spent:

Marginal price — instantaneous ETH cost of the next unit:

Inverse curve — ETH refunded for burning Δ tokens out of a circulating supply of total, sitting on K − total tokens of remaining headroom:

The shape: price starts low, rises smoothly, and accelerates sharply as supply approaches the 21,000,000 cap. Early buyers pay less per token than later buyers — the curve itself is the only "presale," and it's open to everyone, permissionlessly, forever. A live chart of this curve against the current on-chain position, including exactly where circulating supply sits toward the cap, is on the trading page.

4Fees

A combined 1.3% fee applies to every trade, in both directions, computed on the ETH leg and taken off the top before the remainder reaches the curve. It is enforced inside the hook itself, not in the router — so it applies even if someone calls the PoolManager directly, bypassing the router's UI entirely.

On a buy, the fee is taken off the ETH coming in before the remainder reaches the curve. On a sell, the fee is taken off the ETH the curve owes before it's paid out.

5Anti-bot mechanisms

Pure bonding curves are trivially exploitable by bots that buy and instantly resell into a spread-free arbitrage loop, or that snipe the first block with disproportionate capital. broke carries three guards:

• Per-transaction buy cap — 5 ETH maximum per buy. No single transaction can move the curve further than that.
• One-block cooldown — an address that just bought cannot sell until at least one block has passed. This closes the same-block mint-then-burn arbitrage that would otherwise let a bot extract the fee spread risk-free.
• Launch entropy window — for the first 100 blocks after deployment, each buy's minted amount is scaled by a pseudo-random multiplier between 0.9× and 1.1×, derived from the previous block hash, the buyer's address, and their ETH input. This makes precise sniping bots less effective in the opening minutes without meaningfully changing the curve's long-run shape.

6Why trades must go through the router

Uniswap v4 uses flash accounting: the PoolManager tracks running debits and credits during a single transaction and only requires the books to balance to zero by the end. Critically, though, PoolManager.take() — used to physically hand out a currency — requires the manager to already hold that currency's balance. It does not extend credit.

BrokeHook needs to take() the buyer's ETH (or seller's broke) from inside its own beforeSwap callback, before the core swap math runs. A generic router — including Uniswap's own test router — settles the swapper's payment after calling swap(), which is too late: the manager wouldn't have the funds yet, and the take() call would revert.

BrokeSwapRouter fixes this by pre-settling the input currency into the PoolManager before calling swap(), inside the same atomic transaction. This is not an optional convenience — pointing a standard v4 router at this pool will fail.

7What "no admin" actually means here

Concretely, verifiable on-chain:

• BrokeToken.setMinter can be called exactly once, by the deployer address, and only to install the hook. After that call, minter is permanent.
• BrokeHook has no onlyOwner functions of any kind. Every parameter — curve constants, buy cap, cooldown, and fee rate — is set in the constructor and stored as immutable or constant.
• There is no proxy. The bytecode at each deployed address is exactly what was compiled.
• Liquidity can never be added to the pool, by anyone, ever (Section 1).

The only actions any human retains after deployment are: buying, selling, and reading state. Nobody can pause trading, change the curve, mint for free, or redirect anyone else's funds.

8Deployment

All contracts are unverified-by-default on deployment; verify source against the project's src/ directory before trusting any block-explorer display of them.