$HALF is live — the pot below is still a simulation

take half.

One pot. Anybody can take exactly half of it, at any moment, with nobody's permission. Then somebody takes half of what's left. It never reaches zero — and it never waits for you.

1.0000ETH

in the pot · epoch 1

next claim

0.5000

it pays

0.0000

you took

claim #1 of epoch 1 — the biggest one there will ever be

the staircase

every claim is worth half the last one

There is no schedule and no queue. The only thing that decides what you get is how many people got there before you. This is the whole game, drawn to scale.

Payout per claim — epoch 1

ETH per claim · linear scale · hover a bar

taker

took

pot left

rules

four of them, and that is all

Half. Always half.

Any wallet can call claim() and receive exactly half the pot. No maximum, no minimum, no whitelist, no cooldown. Being early is the entire edge.

It never empties

Half of something is always something. The pot is Zeno's arrow — it approaches zero and never arrives. That is not a bug being tolerated, it is the product.

The pot refills

Every trade of the token routes a fee into the contract. Half of that lands in the live pot, half is held back. A busy hour can push the pot back up faster than it is being drained.

Epochs seal

When the pot falls to 1% of what it opened at, the epoch seals on chain forever, the held-back half becomes the new pot, and claim #1 is up for grabs again.

the share

every claim is a receipt

A claim is one transaction, it takes about four seconds, and it produces a number that is either enviable or humiliating. That is the only marketing this has.

post it

the token

$HALF is the fuel, not the point

The pot is the product. The token is how the pot stays fed: a slice of every buy and sell is forwarded to the contract, so the pot grows with volume rather than with promises. Holding it does not entitle you to anything the contract will not give a stranger — there is no staking, no revenue share, and no allocation that unlocks later.

SINK

Trading fee → pot

Fees arrive as ETH through feed(). 50% to the live pot, 50% to the reserve that opens the next epoch.

KEY

No owner

The contract has no owner variable, no admin role, no pause, no upgrade proxy and no rescue function. Read it below — it is 90 lines.

OPEN

Anyone can feed it

feed() is payable and public. If you want claim #1 of the next epoch to be worth talking about, you can make it so yourself.

contract

the whole thing

Not yet deployed. When it is, this page stops being a simulation and starts reading the chain. Nothing in this file changes between now and then.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Zeno {
    uint256 public constant FLOOR_BPS = 100; // epoch seals at 1%

    uint256 public epoch;      // current epoch
    uint256 public openedAt;   // pot when the epoch opened
    uint256 public pot;        // claimable right now
    uint256 public reserve;    // funds the next epoch
    uint256 public claims;     // claims this epoch

    receive() external payable { _feed(msg.value); }
    function feed() external payable { _feed(msg.value); }

    function _feed(uint256 amount) internal {
        uint256 toReserve = amount / 2;
        pot     += amount - toReserve;
        reserve += toReserve;
        emit Fed(msg.sender, amount - toReserve, toReserve);
    }

    function nextTake() external view returns (uint256) { return pot / 2; }

    function claim() external lock returns (uint256 take) {
        if (openedAt == 0) { openedAt = pot; emit Opened(epoch, pot); }

        take = pot / 2;
        if (take == 0) revert Empty();

        pot -= take;
        totalTaken += take;
        emit Claimed(msg.sender, epoch, ++claims, take, pot);

        if (pot * 10_000 <= openedAt * FLOOR_BPS) _roll();

        (bool ok, ) = msg.sender.call{value: take}("");
        if (!ok) revert SendFailed();
    }

    function _roll() internal {
        emit Sealed(epoch, claims, pot);
        uint256 next = reserve + pot;   // dust rolls forward
        reserve = 0; pot = next; openedAt = next; claims = 0;
        unchecked { epoch += 1; }
        emit Opened(epoch, next);
    }
}