HEAD

A deterministic on-chain state written by market activity.

HEAD is a Robinhood Chain token whose Uniswap v4 hook converts every successful swap into the next cryptographic state. Supply is fixed at 499,000, fees are fixed at 2.00% on buys and 3.00% on sells, and a single contract carries the token, the hook, the fee logic and the state at once. Right now that state stands at 0x0000…0000, written by swap #0 in block 0, and independently reconstructed by GitHub as Matched.

Every swap leaves a trace. Every trace changes HEAD. The repository does not decide the state — the market writes it.

View contract GitHub repository Follow on X

Pool HEAD / ETH Head 0x0000…0000 Swap #0 Direction — Status Verified Last —

HEAD is not a dashboard. It is not a market predictor. It is not controlled by the repository. It is the state the market leaves behind.

01 / Overview

Protocol overview

499,000 Total supply
2.00% Buy fee
3.00% Sell fee
1 Deployed contract

One contract.
One pool.
One continuous cryptographic state.

There will only ever be 499,000 HEAD. The fee structure is fixed and HEAD is not a dynamic-fee system — the hook never rewrites the 2% / 3% schedule to chase volume. Its purpose is the state it leaves behind.

There is always one current HEAD. A new swap changes it. The next swap starts from that exact state, which is what makes the history a single continuous chain rather than a log of independent entries.

02 / State

Current HEAD

0x0000000000000000000000000000000000000000000000000000000000000000
Previous HEAD 0x0000…0000
Swap index #0
Last block 0
Last direction —
Pool HEAD / ETH
Chain Robinhood Chain
GitHub state Matched
Transition rule keccak256
  1. Previous HEAD
  2. Swap fingerprint
  3. keccak256
  4. Current HEAD

03 / Mechanism

How HEAD works

The hook runs inside the pool callback, so a state transition cannot be separated from the swap that caused it. If the swap reverts, no state is written.

  1. 01

    Swap

    A swap settles through the HEAD / ETH Uniswap v4 pool.

    afterSwap

  2. 02

    Fingerprint

    The hook derives a deterministic representation of the swap from on-chain data only.

    keccak256(isBuy, sizeBucket, block, previousHEAD, poolId)

  3. 03

    Update

    The previous HEAD and the new fingerprint are combined in that order.

    abi.encodePacked(head, fingerprint)

  4. 04

    State

    A new HEAD is produced and stored on-chain, replacing the previous one.

    bytes32 public head

  5. 05

    Event

    The transition is emitted publicly, carrying both sides of the change.

    event Commit

  6. 06

    Verify

    GitHub reads the events, replays them and compares the result to the stored state.

    CURRENT.json

Order matters

The previous state is always the first argument. Swapping the operands produces a different chain, so a reconstruction that disagrees on order disagrees on every state after the first.

Index is monotonic

The counter only increases and only inside a settled swap. Gaps are impossible; a reader that finds one is reading an incomplete event set.

Genesis is a constant

The root is fixed at construction from the chain id and the contract’s own address, not from an owner-supplied value — so there is no privileged first state anyone had to be trusted with, and the same bytecode on another chain produces a different, non-colliding history.

Reverts write nothing

State is written in the same call frame as the swap. A failed swap leaves HEAD untouched, which is why the history contains only settled market activity.

04 / Rule

The formula

HEAD[n+1] keccak256(HEAD[n], SWAP[n])

Every state depends on the state before it.

  • No editable history.
  • No manual state updates.
  • No external oracle.
  • No privileged writer.
  • Only the next state.

05 / Authority

Chain → GitHub

Most token repositories describe a project. This one is generated from the project’s actual on-chain history. Nothing in it is supposed to lead the chain — it follows it.

  1. Chain
  2. HEAD contract
  3. Event history
  4. GitHub reconstruction

GitHub does not control HEAD.

The repository has no authority over:

  • balances
  • fees
  • liquidity
  • token supply
  • hook logic
  • HEAD state

It can only verify. It reconstructs what has already happened on-chain, and the one direction that is never permitted is GitHub → chain.

The market writes. The chain settles. GitHub verifies.

06 / Verification

System verification

This page is itself a reader. It recomputes each commit from its own event data in your browser — the same arithmetic the contract runs — and checks that the run links together and lands on the pointer the contract reports.

On-chain HEAD 0x0000…0000
Reconstructed HEAD 0x0000…0000
Match Yes
Processed swaps 0
Last verified block 0
Repository status Synchronized

This page recomputes the state chain in your browser from on-chain events.

07 / Rewards

Claim

Every swap fee is taken in ETH and paid out to holders in proportion to the HEAD they hold — there is no staking and no minimum balance. Your claimable amount is read straight from the contract; the panel stays locked until a wallet is connected.

Locked
Address Not connected
Network —
Claimable —
Snapshot HEAD —
Claim status Wallet required

Wallet required

Rewards are paid in ETH, proportionally to the HEAD you hold. Connect a wallet to see yours.

08 / Registry

Token & contract

Token
HEAD
Symbol
$HEAD
Network
Robinhood Chain
Pool
HEAD / ETH
Total supply
499,000 HEAD
Buy fee
2.00%
Sell fee
3.00%
Fee model
Fixed
Token standard
ERC-20
Hook
Uniswap v4
Deployment model
Single contract
HEAD state
Deterministic
Upgradeability
None
GitHub control
None

09 / Deployment

Contract

0x0000000000000000000000000000000000000000

Explorer — at deployment

One contract.

The same deployed contract contains:

  • ERC-20 logic
  • Uniswap v4 hook logic
  • Fee logic
  • HEAD state
  • Event history

Nothing is split across a proxy, a controller or an upgrade path. The address above is the whole protocol.

10 / History

Recent transitions

Streaming

    11 / Reader

    Repository

    The files, hashes and traces inside the repository are reconstructed from HEAD activity on Robinhood Chain. It is generated by the chain, not by hand.

    Repository github.com/headhood/HEADHOOD
    Current commit 0000000
    Chain HEAD 0x0000…0000
    Repository HEAD 0x0000…0000
    Status Verified
    • CURRENT.jsoncurrent reconstructed state
    • history/on-chain trace records
    • generated/files rebuilt from events
    • src/reconstruction logic
    • scripts/reader and verifier
    • tests/transition rule tests
    • .github/workflows/scheduled verification

    Open repository View history @headgithubhood Back to top

    Chain → GitHub