Pinned Tweet
Cleaton $CLEAT is now trading live on Uniswap.
The Tool Integrity Layer for the Agentic Economy on Robinhood Chain.
Official Contract Address:
0x12D4E7C85e66b5260A9a4251620a63E08482ca1E
Do not fall for fake tokens or scam links. Always double-check the contract.
What's next: pSTOCK + ySTOCK. The stock without its income, and the income without the stock. A corporate-actions record underneath, read from the chain, and a venue for either side.
Connect a wallet to open it: dapp.cleaton.xyz/dividends
$CLEAT
A liquidity position is really two things: the principal you put in, and the yield it will earn while it sits there. Today you can only hold both, together, in one pool.
Cleaton already measures everything a split would need - which market, how deep, how long the liquidity holds, what it earns. 900+ pools, read every hour, every figure free over REST.
What's next: LIQ → pLIQ + yLIQ. One position becomes two claims. Hold the principal without the yield risk, or buy the yield without locking the principal. A liquidity yield curve falls out of it - what 30 days of liquidity is worth against 90, against a year.
None of it is minted yet. The measurement is live; the primitive is what it turns into.
Connect a wallet to open it: dapp.cleaton.xyz/split
$CLEAT
Cleaton today: a liquidity intelligence layer on Robinhood Chain, Base and Arbitrum. Every hour it reads 900+ pools and publishes what it can prove — depth, how much of it is standing on rewards, turnover, the calls it has signed, and the dollars it refuses to count.
You can swap from your own wallet, quoted by Uniswap at one block. You can see all 200+ tokenised stocks on the chain, and which of them have a dividend accruing inside. You can check the volume of every venue by day — and see exactly what was held out and why.
What's next:
→ pLIQ / yLIQ — split a liquidity position into principal and future yield
→ pSTOCK / ySTOCK — separate a tokenised stock from its dividend
→ a lending market where liquidity demand meets capital
→ the on-chain registry that grades every call we have signed
Each one is built on data that is already live. The measurement came first; the markets come on top of it.
Open the dapp: dapp.cleaton.xyz · public API, no account: dapp.cleaton.xyz/api/v1/volu…
$CLEAT
`GET dapp.cleaton.xyz/api/v1/swap…<token>&amount=<base units>`
Two tokens and an amount. back comes the route, the amount out, the fee, the impact, and the block it was read at. Uniswap's quoter answered it in the request that served it - this is the one endpoint of ours that is never edge-cached, because a ten-minute-old price shown as live is exactly the number somebody would sign against.
Add `&from=<your address>` and it also returns the transactions, unsigned: the approval if your allowance is short, and the swap. calldata you can inspect, hand to any wallet, or throw away. the address is used to name the recipient and read the allowance, then forgotten. there is no table for it.
An agent can price a trade here without a wallet. a reader can check ours without an account.
$CLEAT
A router address is the most dangerous thing in a swap. a wrong one does not fail - it takes the approval and the funds, and nothing comes back. so for weeks our swap button read "execution not wired": we had no router we could vouch for, and guessing one was out of the question.
We found it in another dapp's bundle on the same chain. that told us where to look. it did not tell us what it was.
What settled it: three calls, each checked against something we already knew independently. `factory()` returns the same factory as the WETH/USDG pool our pipeline has tracked for weeks. `factoryV2()` returns the factory of the CLEAT/WETH pair on /exchange. `WETH9()` returns the WETH held by seventy-odd tracked pools. and the bytecode carries SwapRouter02's selectors, not the older SwapRouter's — the two encode the same call differently, and the wrong payload reverts *after* the approval has gone through.
Then the verification became a test. it re-asks the chain every run. a proxy repointed tomorrow fails the build tomorrow.
And the browser checks too: the router address is a constant in the client bundle, and a payload pointing anywhere else is refused before the wallet sees it. a compromised server can mis-quote. it cannot redirect.
Connect a wallet to open it: dapp.cleaton.xyz/swap
$CLEAT
There is an NVDA/TSLA pool on the factory. it is empty. the quoter reverts on it.
Our first version saw that a direct pool existed and stopped there - so NVDA → TSLA answered "no route" in production, while both stocks trade against USDG a hop away. the fix was one word: a route is tried through a mid when no direct pool answers, not when none exists. Robinhood Chain is full of factory pools holding nothing. existence is not the test. an answer is.
Now: NVDA → USDG → TSLA, two Uniswap v3 hops, eighteen pools asked before that route was chosen. the whole route is quoted end to end at one block, so the number on the panel is what fills - not a heuristic over two halves.
A two-hop route is one transaction. the first leg pays the router, the second spends what the router holds, and the minimum sits on the last leg only. your wallet signs it once.
Connect a wallet to open it: dapp.cleaton.xyz/swap
$CLEAT
Ask the usual icon CDN for NVDA on Robinhood Chain and you get the Robinhood feather. ask for TSLA - the same feather, byte for byte. SPY, same. two hundred tokenised stocks, one picture, and the picture says they are all the same asset.
So we draw something true instead.
A tokenised stock gets the mark of the company its own name() returns - NVIDIA's, Tesla's, Apple's — beside that name, never instead of it. seventeen of the 203 wrappers have one under a free licence.
ETH, WETH and USDG get their real marks, fetched from Ethereum mainnet where the same asset is drawn properly.
SPY and QQQ get none, on purpose. an index fund is not its issuer.
Everything else gets a monogram - up to five letters, because GOOG and GOOGL are two different securities and a four-letter tile would relabel one as the other.
A small privacy note, since the marks live in the swap picker: choosing a token there tells us nothing. the list is served the same to everyone, and which one you pick reaches us only inside a quote request - which is answered and not stored. a logo is not a tracker.
Monochrome throughout. a brand's own colour would be the only off-palette hue on the page.
Connect a wallet to see them in the swap picker: dapp.cleaton.xyz/swap
$CLEAT
Most products tell you they respect your privacy. we would rather tell you exactly what is in the database, column by column, and who can read it. so here it is.
What signing in gives us: your wallet address, the chain it came from, the name of the wallet that announced itself, and a hash of your session - the token itself lives in your browser and is never stored readable. that is the whole account.
What you can add: a watchlist, alerts with a webhook URL and its signing secret, API keys stored as hashes. twelve tables in all, each keyed to your address. every row on the page says what it holds, who can read it and how long it stays. "who can read it" is answered honestly — for most rows it is anyone holding the database, because nothing there is encrypted beyond what is hashed.
What is never stored, and why. your private key - impossible, sign-in is a plain-text signature and a swap is signed by your wallet. your balances, holdings and trades - a decision; the portfolio page answers what you paste and keeps nothing. the swap quotes you ask for — a decision; there is no table. your conversations with the assistant - a decision; each request carries its own turns and nothing is written back. an email, a phone number, a name — there is no field for one.
Who else sees something, because pretending nobody does would be the lie. the model that answers the assistant sees the conversation, not your address. Uniswap sees the swap, on chain, as every swap is seen. your wallet sees what it always sees. your webhook receiver sees the alerts you configured.
And the one thing we will not soften: the edge sees your IP before our code runs. Cloudflare terminates the connection. what reaches our table is a two-letter country code and your browser's user-agent, on the session row, nothing more — and saying "we never see your IP" would be false one layer down.
None of this is a promise. a test walks the migrations, and a new table about a reader fails the build until the page lists it. read it as an inventory.
No account needed: dapp.cleaton.xyz/api/v1/priv…
$CLEAT
Recorded on the dapp: a swap from your own wallet, then the page that lists what we can see about you.
The panel first. pick ETH, pick a stock. the quote is Uniswap's own quoter at one block — never cached. your wallet signs. the router settles. under the button, three lines: we hold nothing, the approval is to the router for this amount only, and this quote is not stored.
Then the card beside it: what we can see when you swap. two tokens, an amount, your address so the calldata can name you. answered, forgotten. afterwards the swap is public on chain like every swap — a block explorer attributes it to you. we don’t
Then the page. every table that holds something about you: your address, a hashed session, a watchlist, alerts, hashed API keys. what it holds, who can read it, how long it stays. for most rows "who can read it" is anyone holding the database, because nothing there is encrypted beyond what is hashed. we would rather say that than let you assume otherwise.
Then what we never store, and why each one is never. your private key - impossible; sign-in is a text signature. your balances and trades - a decision. the quotes you ask for - a decision; there is no table. your conversations with the assistant - a decision; nothing is written back. an email, a phone number - there is no field.
And the edge: Cloudflare sees your IP before our code runs. we say so. what reaches our table is a country code and a user-agent.
None of it is a promise. a test walks the migrations, and a new table about you fails the build until the page lists it.
Connect a wallet to open it: dapp.cleaton.xyz/swap
The inventory without an account: dapp.cleaton.xyz/api/v1/priv…
$CLEAT
ETH, USDG, CLEAT and more than a dozen tokenised stocks - NVDA, TSLA, SPY, QQQ, AAPL and the rest - from the wallet you signed in with.
The quote is Uniswap's own quoter, read at one block in the request that serves it. never cached, never modelled. the transaction goes wallet → Uniswap's router → wallet. we build the calldata; your wallet signs it; the browser refuses any payload that points anywhere but that router.
What we can see when you swap: two tokens, an amount, and your address — so the calldata can name you as the recipient. that request is answered and forgotten. there is no table for it.
What we cannot see: your keys, your balances beyond the one we check so the button can say "you hold less than this", your other trades, where the money came from or where it goes next.
What we never hold: the funds. the approval is to Uniswap's router, for exactly this amount. never to us, never unlimited. if every Cleaton server disappeared mid-swap, nothing of yours would be anywhere but your wallet or the router.
The swap itself is public on chain, like every swap. a block explorer will attribute it to you. we do not — our ingestion reads pools, not addresses.
One thing we got wrong before shipping: CLEAT has nine decimals, not eighteen. the first draft assumed, and quoted a thousand CLEAT as a whole pool. decimals are read from the contract now, and a test fails if they drift.
Connect a wallet to open it: dapp.cleaton.xyz/swap
$CLEAT
The honest answer is that it is not waiting on engineering time.
There are eight gates. two are cleared. of the six left, three are not code at all — they are decisions nobody has made yet, and two of those hold up everything behind them.
Does a published horizon ever become a hit or a miss? we have never graded one. every call we have published is still pending, which means the accuracy record — the thing we say is the whole product — is genuinely empty.
Is cleaton allowed to hold anyone's money? today it is read-only: no custody, never signs a transaction that moves value. a lending market contradicts that sentence, so it gets retired in public or the entities get separated. it does not get quietly outgrown.
Can the party grading the liquidity also lend against it? that is the 2008 ratings structure and it is the specific thing an oracle sells.
No target window, and there will not be one until those are answered. a date here would convert a decision somebody has to make into a deadline nobody agreed to.
Connect a wallet to open it: dapp.cleaton.xyz/launch
$CLEAT
We shipped a stress test, a peer benchmark and an emission-efficiency board today. no new vendor, no new API key, no new cost. every figure on all three was already in the database and nothing was reading it.
That is the pattern we keep finding: a column nobody consumes is a column nobody checks. the first time we read the volume column properly, one stale row turned out to be 99.8% of the total.
The harder half is what we refused to build. the peer page ranks a pool against its own venue, its own asset class and its own chain - and it will not combine those into a single score. a composite would be the only number we publish that a reader cannot check, and it is exactly the number an integration would come to depend on.
It also refuses to rank inside a cohort of fewer than five, refuses to enter an unreported figure as a zero, and refuses to treat "unknown asset class" as an asset class.
One thing it does say, read 8 september: the median pool on arbitrum earns over 90% of its yield from fees. on robinhood chain the median is under a fifth.
Connect a wallet to open it: dapp.cleaton.xyz/peers
$CLEAT
Every pool on an incentive looks fine until the incentive stops. so we removed it.
Not a forecast - arithmetic. we already store what share of a pool's yield is emission rather than fees. the whitepaper already carries the elasticity of deposits to that yield. put one into the other and you get the depth the equation retains.
162 pools qualify. $2.9 billion of depth. between $2.0B and $2.6B of it has no reason to stay.
It is a range because we have not fitted an elasticity to each pool, and publishing one number would be a per-pool estimate we never made wearing the authority of one we had.
It is also an upper bound, not an expectation: the dampening term is set to 1 because we measure neither exit friction nor where else the money could go. real outflow is slower than this.
636 pools cannot be stressed at all. nobody reported both halves of their yield, and a pool nobody measured is not a pool that earns nothing.
Connect a wallet to open it: dapp.cleaton.xyz/stress
$CLEAT
All 203 of these stock tokens hold no code of their own. they run whatever one beacon holds, and that beacon has upgradeTo. one upgrade changes every tokenised stock on the chain at once.
We now record what it points at on every pass. zero upgrades observed since we started watching - which is a dated observation rather than an assumption, and the first thing that would change if it stopped being true.
What is still missing, plainly:
Which declaration caused each rise. we can see a dividend landed and when; we cannot see the corporate action behind it, because no source in our pipeline reports one.
And the 177 wrappers outside a pool we track carry a reading that does not refresh hourly yet.
Both are on the list, neither has a date, and we do not put one there.
Connect a wallet to open it: dapp.cleaton.xyz/registry
$CLEAT
The multiplier tells you a dividend arrived. it does not tell you when.
So we searched for it: binary search the multiplier's value over block height, bounded below by the wrapper's own deployment block, until you find the block where it first held what it holds now.
UPS, 4 september, block 54,361,262. F, 2 september. SGOV, 1 september. AAPL, 14 august, block 36,351,132.
That last one lines up to the second with the timestamp another oracle on this chain publishes for the same event. two independent methods, same block.
It dates the most recent change only — the cumulative multiplier is all one read returns, so an earlier accrual folded into the same value is invisible. not a full history, and we say so on the page.
Connect a wallet to open it: dapp.cleaton.xyz/registry
$CLEAT
We published that these tokenised stocks had no way to pay a holder. we probed 21 function signatures across four families - dividend claim, reward claim, rebase, vault share - and every one of the wrappers missed all four.
The mechanism is a fifth family we had not looked for.
ERC-8056. your balance never moves; the issuer raises a multiplier and each token comes to represent more shares. one eth_call reads it.
10 of them have accrued a dividend that way. two more moved for a different reason — a stock split, one of them exactly 4.0×, and counting that as income would have published a +300% dividend on a real company's stock.
A probe is evidence about the signatures in it and nothing wider.
Connect a wallet to open it: dapp.cleaton.xyz/registry
$CLEAT
Every stock token on Robinhood Chain is now read. All 203.
COVERAGE
· 203 stock tokens — the complete set, derived from the issuer's
own transactions. No indexer, no vendor list, no log scan.
The largest published list we've seen is 149.
· 203 dividend multipliers read. Next best coverage is 9.
· 134 pools, $14.2M of depth behind them.
THE DIVIDEND
· Your balance never moves — the issuer raises a multiplier.
· 10 wrappers have accrued income.
· 2 are stock splits, not income. One reads exactly 4.0×, and
counting that as a dividend would publish a +300% one.
THE STRIP
· One vault on this chain separates a stock from its dividend.
· Backing 1.0000× — the stock held matches the claims issued.
· 200 days to maturity, not yet settled. Solvent.
· Nobody else publishes this. We read it live.
SECURITY
· All 203 wrappers hold no code of their own.
· One beacon governs them, and it has upgradeTo — one upgrade
changes every stock token on this chain at once.
· The address that deployed all 203 has zero bytes of code:
a private key, no timelock, no threshold.
· No blacklist, no forceTransfer, no seize. The misses reassure.
Connect a wallet to open it:
dapp.cleaton.xyz/dividends
$CLEAT
Every tokenised stock we track on robinhood chain is an EIP-1967 beacon proxy. 283 bytes each. all of them point at the same beacon.
So there is one implementation to inspect, not 26.
We pulled its bytecode and searched the dispatcher for 21 selectors — every way an ERC-20 can hand someone income. claim, reward, rebase, vault share.
Zero hits. transfer, approve, permit, mint, burn, pause. no payout path in it.
Absence is evidence, not proof — and a beacon can be repointed, so this is the code at the block we read.
dapp.cleaton.xyz/dividends
$CLEAT
On robinhood chain, FOX is a token whose on-chain name is "Robin Hood". AI is "Artificial Inu". NET is "NetNet".
None of them is the company.
So we stopped matching symbols and read name() on every token we track, keeping only the ones carrying the issuer's own marker. 26 of them.
Our own ticker list had missed 8 — a third of the real set, on the chain this product is about.
docs.cleaton.xyz/changelog
$CLEAT
Robinhood Chain lists 200+ stocks. Not one of those tokens can pay its holder.
We read name on every token we track and kept the ones carrying the issuer's marker. 26.
All 26 are beacon proxies pointing at the same implementation — one contract to inspect, not 26.
We searched its dispatcher for 21 selectors: every way an ERC-20 can hand someone income. Claim, reward, rebase, vault share.
Zero hits. transfer, approve, permit, mint, burn, pause. No payout path in it.
$289M traded in 24h against $44.7M of depth. GameStop turned over 34x its own depth.
Next: a corporate-actions record, then the contract that separates a stock from its income. Neither exists yet.
Connect a wallet to open it:
dapp.cleaton.xyz/dividends
$CLEAT




















