v0.1.0
pre-launch
Robinhood Chain
engine 17 tests
0000000
Robinhood is a token launched on Pons, on Robinhood Chain. Pons holds the creator rewards from every trade in its fee escrow. Every three minutes the engine claims them, keeps a small gas reserve, and spends everything else buying the token, with the buy delivering the tokens straight to the burn address. They never sit in a wallet anyone controls. Only claimed rewards are spent: whatever was in the wallet before the first claim is recorded and never touched.
Every claim and every burn is a public transaction. This page renders the ledger the engine wrote.
0x6d1b86adfd30d7913d5f0dae6568bd566e6b6327
Source: data/faucet.json, written by the engine after every cycle.
Mechanism
Pons credits creator rewards, in ETH, to the dev wallet's balance in its fee escrow. Each cycle
the engine calls claim() on the escrow, keeps a fixed gas reserve out of what
arrived, and sends the rest into a single buy with the recipient set to the burn address: on the
Pons bonding curve before the token graduates, on its Uniswap v4 pool after. The tokens go
from the market to 0x…dEaD in the same transaction. The engine then checks the wallet moved
by exactly the amount sent plus gas, and refuses to record the cycle if it did not.
Policy
The routing policy is a single entry in engine/src/config.ts. The engine imports
it to settle and refuses to start if it does not sum to 10,000 basis points; this page reads
a generated copy. Changing it is a commit that changes both at once.
Every creator reward claimed from the Pons fee escrow is spent buying the token, on its bonding curve before graduation and on the Uniswap v4 pool after, with the tokens delivered directly to the burn address.
0xd3AF…Ac9e; claim() pays the caller its accrued creator rewardsbuy() until graduation; Uniswap v4 via the Universal Router afterBurn log
One row per burn, newest first. Open a row for the venue, the quote, the bound, the claim that fed it and the block.
| # | When | Venue | Spent | Burned | vs quote | Transaction | Details |
|---|---|---|---|---|---|---|---|
| Loading… | |||||||
Verify
A burn is a normal transaction. On the explorer, the token's Transfer event in
that transaction has the burn address as its recipient, and the transaction's value is the
ETH spent. Paste a hash to look it up in the ledger and get the explorer link; or check it
with the CLI, which reads the receipt from Robinhood Chain.
No lookup yet. Nothing you paste leaves this page.
From the CLI, against the chain: faucet verify <txhash>
If tokens landed in the dev wallet first, there would be a moment where they could go somewhere else. Naming 0x…dEaD as the recipient of the buy removes that moment. The buy and the burn are one atomic transaction, on the curve and on the pool alike.
A buy with no minimum output is an invitation to be sandwiched. The engine quotes first, sets minOut at the quote less 3%, and the market reverts rather than fill below it. The node refuses such a buy before it is even signed, so it costs nothing.
Spending the wallet to zero would strand the next cycle. A fixed reserve stays behind, and the conservation check confirms gas came out of it, not out of the buyback.
Notes
Everything Pons credits the dev wallet in its fee escrow is claimed and, above a fixed gas reserve, spent on the token and burned. There is no team allocation from rewards and no second recipient. Gas for the claim and the buy comes out of the rewards, never out of the wallet's own balance.
On its first cycle the engine records what is already in the wallet and treats that amount as untouchable. From then on it spends only the pool of claimed rewards, measured both as the wallet balance above that baseline and as the ledger's claims net of buys and gas, taking the smaller. ETH sent to the wallet from anywhere else is not a reward and is left alone.
The engine is real and tested: a real EVM runs the claim, the buy and the burn in the test suite, and the Pons and Uniswap v4 calls were checked against Robinhood Chain by simulation. The ledger on this page starts empty and fills only with real transactions. Until the first cycle it shows zero, and that is the truth.
The dev wallet's key is needed only to sign the claim and the buy. The engine reads it from the environment at run time, never from a file in the repository, and checks the signer matches the configured wallet before it will send.
If nothing is claimable, or the spendable balance is under the minimum, the cycle does nothing and the rewards wait for the next one. Spending most of a small reward on gas would be a worse outcome than waiting.
A Pons launch trades on its bonding curve until it graduates, then on a Uniswap v4 pool guarded by the Pons hook. The engine reads the launch record each cycle and buys wherever the token trades now. Both venues deliver to the burn address directly.
If the market moves more than the bound between quote and fill, the buy reverts. The ETH stays in the wallet, the engine reports it rather than retrying blind, and the next cycle quotes again.
This is an experimental token with no promise of value, liquidity, or return, and a real chance of going to zero. A buyback does not change that. Nothing here is financial advice. Read the code before you touch it.
Status
| Engine | v0.1.0 · 17 tests passing · one runtime dependency (ethers) | ok |
|---|---|---|
| Chain | Robinhood Chain · chain id 4663 | set |
| Pons | fee escrow 0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e | verified |
| Token | 0x6d1b86adfd30d7913d5f0dae6568bd566e6b6327 | unset |
| Dev wallet | to be provided | unset |
| Funds | untouched not recorded yet · claimed pool 0 ETH | pending |
| Ledger | 0 claims · 0 burns · none yet | empty |
| Site | Static, built from 0000000 on main, today | live |
faucet doctor clean