Nothing to stake.
Nothing to claim.
There is no staking contract. You hold $WRP, and every hour, on the hour, the balance in your wallet changes. No deposit, no lockup, no claim button. The wallet is the vault.
__CA__
Reading Robinhood Chain over JSON-RPC, live, from your browser. No backend, no key.
Hold it. That is the whole instruction.
Every rebase protocol on this chain asks you to send tokens to a contract first. This one does not. On the hour, the supply index moves, and every wallet's balance moves with it, in place. You never send anything anywhere and you never sign anything to collect.
- Rebase index, now
- 1.000000
- Rate per hour
- —
- Rebases per day
- 24
- Compounded per day
- —
The index is one number. A wallet's balance is its units times the index, so when the index moves on the hour, every balance moves with it and nobody has to do anything. The clock is wall time, top of the hour UTC, which is what the contract will use.
index(t) = (1 + rate) ^ hours_since_genesis
balance(wallet, t) = units(wallet) × index(t)
rate = — per hour, stated on this page
no stake() no claim() no approve()
Anyone can recompute the index from the rate and the clock. There is no server in the loop and no number held back.
No staking contract
Not disabled, not coming later. There is no contract to send tokens to in this design at all. If a site asks you to stake WRP, it is not this one.
The hour is the epoch
Twenty four rebases a day, on the hour, UTC. NAGA rebases every eight hours, Prism six, Lucky four. This one is not mistaken for any of them.
The rate is printed
One stated rate per hour. Every figure on this page is computed from it at runtime, so the copy cannot drift from the number the code uses.
Nothing to claim
There is no claim button because there is nothing held back to claim. The balance in your wallet is the balance. It changes, and that is the event.
Nothing here can move a token
This page requests account access and reads balances. It never asks for a signature, an approval or a transaction. Grep the served script yourself; the count comes back zero.
Real today, stated plainly
The chain reads and the wallet reads are live. The rebase is design intent until its contract exists. The table below says which is which, and it will not soften.
Connect, and the page reads your wallet off the chain.
Not a mockup. Connecting requests account access and nothing else. The balance and transaction count come straight from Robinhood Chain over JSON-RPC in your own browser, and the next-rebase figure is the model applied to what it finds.
No wallet connected. Connect one on Robinhood Chain and this panel fills with what the chain says about it.
MetaMask or any EIP-1193 wallet. If the wallet has never seen chain 4663 the page offers to add it, with the public RPC and explorer, and nothing else.
- Account
- —
- ETH balance
- —
- Transactions sent
- —
- WRP balance
- —
- eth_requestAccounts
- asks for your address
- eth_getBalance
- reads ETH
- eth_getTransactionCount
- reads the nonce
- eth_call balanceOf
- reads WRP, at launch
- Send a transaction
- absent
- Ask for a signature
- absent
- Request an approval
- absent
A pre-launch site asking for a signature is what a drainer looks like. This one cannot, and you can check the script rather than take that on trust.
Set a holding. Watch a month of hours.
Everything in this panel is arithmetic on your slider and one stated rate of — per hour, compounded 24 times a day. Nothing here is on chain and nothing is promised. It is what the mechanism does to a number, drawn out.
Thirty days of hourly compounding takes this holding to — units. Units, not value. The token can be worth less at the end of the month than at the start for every ordinary reason a token's value falls, and no rebase changes that.
The dashed line is what a plain token does: nothing. The filled curve is the same holding under the stated rate. Move the slider and both redraw.
Read this part first.
The token that launches on pons is a plain ERC-20 with a fixed supply. The hourly rebase is the protocol being built on top of it, and until that contract is live and audited, the balance in your wallet does not move. This table is the honest state of the project and it is updated before anything else on the page.
| Thing | State | What that means | |
|---|---|---|---|
| Block height, gas, client string | Live | Read from Robinhood Chain over JSON-RPC in your browser, several times a second. | |
| Wallet connect and balance reads | Live | EIP-1193 direct. Your ETH balance and transaction count are read from chain 4663 the moment you connect. | |
| The clock | Live | Wall time to the top of the hour, UTC. It is the schedule the contract will follow. | |
| The token, at launch | At launch | Live | A fixed-supply ERC-20 launched through pons_v2. One billion units to a bonding curve, no presale, no team allocation. Its address is published here and on X at the same moment, baked into this page. |
| The hourly rebase | Design intent | Not live. The index, the rate and every rebase figure on this page are the model. The rebase contract is next, and it is audited before it touches a balance. | |
| The rate | Placeholder | — per hour is a stated placeholder, written here so it can be checked against whatever the contract ships with. If it changes, it changes here first. |
Fixed supply, stated plainly.
WRP on Robinhood Chain. Supply is fixed at launch and the figure above is read from the token contract with totalSupply once there is one to read. Before launch it is the intended number and nothing more.
Twenty four rebases a day. Not six hours, not eight, not four, so it is not mistaken for anything already running on this chain.
No buy or sell tax. The rebase is the mechanism and there is nothing else.
WRP. Wallet Rebase Protocol, three letters, and the same word as the domain and the handle.
Robinhood Chain, id 4663, an Arbitrum Orbit rollup. The client string in the strip above is read live.
Shipping in public, without dates.
Now
This page. Live chain reads, the wallet reader, the hourly clock, and the model with its rate printed.
Next
Token launch on pons_v2. The contract address appears here and on X at the same moment, baked into the served HTML.
Then
The rebase contract. The index moves on chain, on the hour, and every balance moves with it. Audited before it touches a balance.
Later
Rebase history you can query, per wallet, and the genesis timestamp read from the contract instead of stated here.
Straight answers.
Where is the stake button?+
There is none, and not because it is unfinished. The design has no staking contract at all. The supply index moves on the hour and every wallet's balance moves with it, in place. If a site asks you to stake WRP, it is not this one.
Is my balance moving yet?+
No. The token that launches on pons is a plain ERC-20 with a fixed supply. The hourly rebase is the protocol being built on top of it, and until that contract is live and audited the balance in your wallet does not move. The table above says so and it is updated first.
Can this page move my tokens?+
No, and you do not have to take that on trust. Connecting requests account access and reads balances, which is all it does. Fetch the script and search it for the ERC-20 write selectors or any signing method; there are none.
Why every hour?+
Because the balance changing is the entire product, and a balance that changes twenty four times a day is one you can watch. It also means the countdown on this page never has more than sixty minutes on it, and it means the protocol is not mistaken for anything already running on this chain at six, eight or four hours.
Is the rate real?+
It is a stated placeholder. — per hour is the number the model computes with, and it is written here rather than implied so that it can be checked against whatever the contract ships with. If it changes, it changes here first.
Units go up. Does value?+
Not necessarily, and it would be dishonest to imply otherwise. A rebase changes how many units every wallet holds; it does not change what the market pays for the whole supply. The token can be worth less after a month of rebases than before them, for every ordinary reason a token's value falls.
How do I know the address is real?+
It is published in a pinned post on X and on this page at the same moment, baked into the served HTML rather than written in by script. Nowhere before that, nowhere else after. Any address you see anywhere else is a copy.
The wallet is the vault.
Connect one, read it, and watch the clock for a while before you decide anything. The chain reads are real, the rebase is stated for what it is, and nothing on this page can move a thing.
contract __CA_SHORT__No contract address yet. When there is one it is published here and on X at the same moment, and it will be in the page source rather than written in by script.