v4, 2026-08-15. Figures pulled live from
/api/coverage on hashling.xyz and verified against the
launchpad contracts themselves.
Hashling is three things on Robinhood Chain (chain ID 4663): a discovery layer for every launchpad token, a launchpad for creating new ones, and a trading front end that reaches every one of them, bonding curves and Uniswap v3 pools alike.
Launchpads on Robinhood Chain start every token on a bonding curve. A token only becomes a Uniswap v3 pool when its curve fills. Screeners index pools, so for the entire life of a project before graduation, and for most projects forever, no screener holds anything at all. Hashling indexes the chain instead of the pool, and follows each project from hatch through bonding to graduation.
The two halves are the same argument. Of 10,870 tokens launched on this chain, 10,070 have never had a single trade. Many were never meant to succeed, test mints, bot spam, and duplicates are a real share of any launchpad’s history. But there is no way to tell which is which from a screener, because none of them appear in one at all. A venue that indexes every launch on the chain, including its competitors’, is a venue where launching means being findable on day one.
Discovery covers the whole chain and always will. Hashling ranks its own launches by the same query as everyone else’s.
The durable record is the project, not the contract. Contracts are something a project has, not what it is. At graduation the pool address changes; the project’s URL, chart, comments and history do not.
projects → assets/contracts → markets/pools → events/time-seriesHashling is non-custodial end to end. The discovery layer reads the chain and holds no user funds; every launch and trade is signed by the user’s own wallet; the curve contracts hold reserves with no owner or admin; and liquidity migrates to a locked Uniswap v3 position at graduation.
Status: the discovery layer is live at hashling.xyz
and indexing today. The launch factory described under Fee
schedule is deployed on Robinhood Chain mainnet at
0x3b38c6Fa9Cc41d3A20d64111325231E7dEF7D523, source-verified
on Blockscout, and unaudited. Graduation to Uniswap v3 is not yet
enabled on-chain; graduate() reverts until the migrator
ships, so no fund-holding migration path exists yet. See
Graduation for how it will work once enabled.
| Metric | Value |
|---|---|
| Contracts indexed | 12,444 |
| Classified to a verified factory | 10,870 |
| Unclassified deployments | 1,574 |
| Hatched (never traded) | 10,070 |
| Bonding | 453 |
| Abandoned | 326 |
| Graduated to Uniswap v3 | 21 |
| Snapshot history since | 2026-08-09 (3 days at time of writing) |
Read across that table: of 10,870 classified tokens, 800 have ever traded and 21 have graduated. For the other 10,070 there is no pool, no chart, and no screener listing anywhere.
This coverage figure is auditable, and the audit takes one
call. Each launchpad factory publishes its own token count on
chain. Calling tokenCount() on the two indexed launchpad
factories returns 10,575 and 295, 10,870, matching the number of
classified tokens in the index exactly. Anyone can run that
eth_call against a public RPC and check this paper’s
central claim without asking us for anything:
0x5fcc1df0dc020cf454e742e9a8ae2554c37a452c tokenCount() → 10,575
0x8c529f0a77c07ce0e6796f153d292501ee6f66f6 tokenCount() → 295
index holds → 10,870A coverage claim that can only be checked against our own API is a marketing number. This one is checked against the counterparty’s contract.
The 1,574 unclassified rows are contract deployments found by the generic scanner that no venue adapter has claimed yet. They are shown as unclassified rather than dropped, because a token we cannot name is still a token that exists.
Curve mechanics deliberately match the established launchpad on this chain, so a creator comparing venues has exactly one number to read: migration.
| Parameter | Hashling | Other launchpad |
|---|---|---|
| Launch cost | gas only | gas only |
| Trade fee | 1% flat | 1% flat |
| Creator share of curve fees | 80% | 80% |
| Protocol share of curve fees | 20% | 20% |
| Curve allocation | 80% of supply | 80% of supply |
| Uniswap pairing | 20% of supply | 20% of supply |
| Uniswap v3 pool trades (HashlingSwap) | 1% of ETH in / out | n/a |
| Virtual ETH seed † | 2.81 ETH | 2.81 ETH |
| Graduation raise target † | ~6.5 ETH | ~6.5 ETH |
| Migration cost | 0.25 ETH + 3% of raise | 0.5 ETH + 3% of raise + 0.05 ETH |
| Post-graduation pool fee | 1% per swap | 1% per swap |
† Seed and target are the values at the default 1B supply. Both scale with the supply a creator chooses, so neither is a protocol constant, and neither should be quoted as one.
Migration is where a creator feels the fee, because it is charged in one visible amount at the moment the project succeeds. On a ~6.5 ETH graduation the numbers above work out to 0.445 ETH on Hashling and 0.745 ETH on the other launchpad; both are published constants and either can be recomputed from the table.
A flat fee denominated in ETH grows in dollar terms whenever ETH appreciates. That applies to Hashling’s 0.25 ETH flat component exactly as it applies to anyone else’s, stated here so the exposure is understood rather than discovered.
Audit status: unaudited. The contracts have not been reviewed by a third party. Their security argument today rests on an invariant-fuzzing suite run against every release. Stated here so it is not discovered later.
When a curve’s real ETH reserve reaches its raise target, the token is eligible to graduate: the raise (less the migration fee) and the reserved 20% of supply move into a Uniswap v3 pool, and the liquidity position is locked, no withdraw function, no owner, no admin.
graduate() is permissionless: anyone
may call it once the target is met, so no one, including us, can hold a
full curve hostage. In practice nobody should have to. The same
scheduled tick that reads every curve already knows the moment
realEth meets raiseTarget, and it will submit
the graduate() call itself. Graduation is therefore
automatic: filling the curve is the only thing a
project has to do, and the migration follows within one tick (about ten
minutes) without a button, an application, or anyone’s permission.
Until the Uniswap v3 migrator contract ships, graduate()
reverts by design, the contract refuses to hold a migration path that
has not been built and fuzz-tested to the same standard as the curve.
The bonding curve is fully functional in the meantime: buys and sells
work, and a full exit is always possible. The migrator will be deployed
and verified before any live curve approaches its target, and this
section will be updated from “will” to “does” when it is on-chain.
Every token Hashling indexes can be traded on Hashling, the same page that shows its chart, its history and its creator’s statements. There are two kinds of market on this chain, and Hashling handles both.
Bonding curves. A Hashling token trades against the Hashling factory; a hood.fun token trades against hood.fun’s own verified factory, from a Hashling page. Nothing is intermediated: the order goes from the buyer’s wallet to the launchpad contract, and the launchpad’s fee split applies exactly as it would on the launchpad’s own site. Hashling routes hood.fun curve trades because hood.fun’s front end frequently cannot complete them, the contract works, the page does not, and a project should not lose a buyer to someone else’s bug.
Uniswap v3 pools. Once a curve graduates, or when a token was launched straight into a pool, its market is a Uniswap v3 pool, and no launchpad front end on Robinhood Chain reaches those. Hashling does, through HashlingSwap: a small, immutable contract (no owner, no pause, no upgrade, no custody between transactions) that takes a 1% fee and forwards the order to Uniswap’s SwapRouter02. Buys pay the fee from ETH in; sells pay it from ETH out. The pool is discovered live, every standard fee tier is queried and the deepest wins, so a token is tradeable the moment anyone provides liquidity, with no listing step. Real projects that people put work into keep a market even when the venue that launched them is gone; that is the reason this exists.
Simulate first, always. Every order, curve or pool, is simulated against the node before it reaches the wallet, and a refusal is explained in plain English (max-holding caps, slippage, insufficient balance) instead of “unknown RPC error”. Pool orders carry a 5% maximum slippage and a short deadline. Nothing is sent that the chain has not already said it will accept.
Discovery reads raw chain data. A generic scanner finds every contract deployment in a block range; venue adapters only classify what the scanner already found.
Two consequences follow, and they are the architectural point of the product:
Launchpad APIs and block explorers are cross-checks and outbound links. They are never a dependency for a token’s existence or its history.
Status is derived in one place (src/core/lifecycle.ts)
and never written by ingestion. States and permitted transitions:
| State | Meaning |
|---|---|
unclassified |
Deployment found, venue not yet identified |
hatched |
Launched, never traded |
bonding |
Curve has taken value |
near_graduation |
Curve close to full; can fall back |
abandoned |
Traded once, then went quiet |
graduated |
Terminal. Set only by an observed on-chain graduation |
graduated is never inferred from a bonding percentage.
near_graduation can revert to bonding, because
a curve can and does empty out.
One launchpad on this chain grinds CREATE2 salts so its token
addresses end in 600d. That suffix is a useful hint and
nothing more, anyone can grind it for the cost of some CPU.
| Tier | Basis | Badge |
|---|---|---|
factory_verified |
Deployed by a known factory contract, read from chain | Yes |
| suffix / heuristic | Address pattern or metadata match | No |
A token wearing the 600d suffix that the factory did not
deploy is an impersonation signal that no API-sourced screener can
produce, because the launchpad’s own API will simply not return it.
The defence is not moderation; it is that the deployment transaction is a fact and a name is not.
Creators supply artwork at launch and it is written into the token’s on-chain metadata. Hashling decodes it from there during ingestion.
This is a mechanism claim, and it is checkable: pick any recent launch, decode its on-chain metadata, and compare it to the tile on the board. The art a creator embeds at launch is part of the launch transaction itself. Reading it from chain metadata rather than from any venue’s asset pipeline means it cannot go missing on a project’s most important day.
Hashling snapshots every tracked project on a fixed tick and stores the time-series in D1. Snapshots are written on change, so a quiet chain writes no rows, silence is not a gap.
This is the one asset that cannot be backfilled, by anyone, including us: nobody can go back and record what a curve looked like on a day they were not watching. That is a property of the method, not a claim about depth, the series starts 2026-08-09 and is exactly as long as it has been running.
Movement queries (30m–14d) are answered from that series, with one rule that matters more than the feature:
When the requested window is longer than the recorded history, the API returns
full_window_covered: falserather than reporting zero movement.
“Nothing moved” and “we cannot see that far back” are different claims, and a data product that conflates them is not one.
The same discipline governs alerts, which ship as three surfaces over
one query: a page, a JSON API, and RSS, global, or per project. Fields
are named *_bonding_pct, never bare pct,
because on a bonding curve a 25-point fill move is not a 25% price move
and a feed reader cannot tell them apart. Every item carries the ETH
size beside the percentage, because a percentage alone cannot
distinguish one buy from fifty. Responses carry truncated,
qualifying and count, so the feed can never
publish a number it cannot back.
Delivery is deliberately feeds, not subscriptions. There is no account, no email list, and no record of who is watching what: a reader polls a URL. That is a privacy property, but it is also a durability one, a feed cannot be revoked by losing an account, and it costs the same whether one person subscribes or ten thousand do.
Two problems, one mechanism.
Claiming a project. A creator proves control by signing a message with the deploying wallet. The server recovers the signer. No admin access changes hands, no files are surrendered, nobody has to be trusted, which is precisely what the people who target new projects are asking for when they offer help.
Commenting on a project. To say something about a token, hold it. The server recovers the signer and reads the balance from the token contract itself. Nothing about the holding is taken from the browser.
Presenting the project. The same signature lets a creator set the project’s banner and replace its artwork, uploaded to Hashling’s own storage, or by URL, and its links. Nothing is pulled from any other venue’s servers: what appears on a Hashling page is what the chain says or what the creator supplied. When copycats appear, the real creator’s signature is the thing a copycat cannot produce.
Speaking as the project. A claimed creator can publish statements on their own page, updates, corrections, and, when copycats appear, “this other token is not us,” said exactly where buyers are looking. Statements are dated and append-only: earlier ones stay readable and nothing is overwritten, so the record is trustworthy precisely because it cannot be quietly edited.
The stake is share of supply, never a dollar amount. Most tokens here have raised under 0.01 ETH and have no meaningful price at all; a wallet holding 33 million of one shows $0.00. A dollar threshold would be both unmeasurable and purchasable for pennies. A supply threshold needs no price feed.
This also scales the right way against an attacker: to spam a hundred projects you must buy a hundred tokens. Cost rises with the breadth of the attack, which is not true of any subscription-priced verification.
Creator identity is read from the creation transaction’s
sender, not from the launchpad’s creator field, on
a community launch that field is a contract, not a human. Hashling
therefore agrees with what the explorer already shows rather than
asserting a fourth answer.
Placement can be bought for a few dollars and is proved by signature: no account, no application, no relationship with anyone.
The core tracker stays fully useful without payment. There is no pay-to-hide and no paid ranking.
Stated here rather than left to be discovered:
last_indexed,
not the latest snapshot timestamp.creator column that was wrong for 167 of 797 projects, with
no visible symptom, all addresses plausible. A site that publishes
claims about other people’s projects has to be willing to do that.Hashling is experimental software that reports on-chain data about highly volatile assets. Nothing here is financial advice, an endorsement, or a verification of any project’s intent or quality. Most tokens go to zero. Data may be incomplete, delayed, or wrong; verify anything that matters against the chain.
Corrections, questions, and project claims: [email protected]. Site: hashling.xyz. X: @hashlingxyz.