How SHARPS works

Every listing on SHARPS is tied to a single, real wallet on Robinhood Chain — a trader whose on-chain activity is public. Instead of buying the coins they trade, you buy shares in the trader themselves. As their tracked performance moves, so does the price of their stock.

Trading is genuinely on-chain: buying and selling call the SHARPS contract directly, your shares are recorded in that contract's own ledger against your address, and the ETH behind every listing sits in that listing's own on-chain vault — not in a company account.

Price, chart, and market cap are served from one shared feed rebuilt from the contract's own on-chain events — so every trader looking at a listing sees the same numbers at the same moment, rather than whatever their own browser happened to poll.

Each listing has a ticker (like $COOK), a name, and a linked wallet address you can verify yourself on any Robinhood Chain explorer. A listing exists on-chain once it's been created by the contract admin — until then it shows an estimated price only, and can't be traded.

Share cap

10,000,000 shares max per listing — a comparability constant, not a solvency limit.

Open price

Every listing opens at a neutral baseline (score 50) the moment it's created.

Verification

The linked wallet is public — check it against the trader's real on-chain history.

A listing is a wallet address first and a person second. The address is the part that's verifiable; the name, avatar, and X link attached to it are best-effort labels from public wallet-tagging data.

124 of the 126 listed traders have a name, avatar, and linked X account. 2 are genuinely untagged and show a shortened address instead. Those are left blank rather than guessed — attributing the wrong X account to a real trader is worse than showing none at all.

Each listed wallet is read directly from the chain and reduced to four measurements over a trailing window: realized PnL, win rate, volume, and trade count.

Each is converted to a percentile rank against every other listed trader — so a score answers "how does this trader compare to the field", not "how big are their numbers". Someone doing $10M of volume and someone doing $10k are directly comparable. The four percentiles are then blended by weight:

50%

Realized PnL — the strongest single signal of skill.

20%

Win rate — consistency.

15%

Volume — conviction, log-compressed so whales don't flatten everyone.

15%

Trade count — activity and sample size.

Because it's a ranking, a score falls as well as rises. A trader can have a decent month and still slide if the rest of the field did better.

Two more brakes: a trader with no post-launch trades sits at exactly 50 (everyone starts equal), and the score moves at most 25% of the way toward its new target per update cycle.

Price comes from two things multiplied together: a bonding curve that responds to supply, and a score multiplier that responds to performance.

The curve. Each share costs slightly more than the one before it. Buying walks the price up; selling walks it back down. Crucially, every wei paid in stays in that listing's own reserve, and the reserve is kept exactly equal to the curve's value of all outstanding shares. That equality is what guarantees a sell can always be paid in full.

The multiplier. A limited-privilege oracle key pushes each trader's score (see the scoring model) to the contract, and the contract turns that score into a multiplier on the whole curve. Score 50 is neutral (1×); higher lifts the curve, lower drops it.

A falling score applies immediately and in full, since it shrinks what the reserve has to cover and can never threaten solvency.

The oracle key is deliberately narrow: it can only push scores. It cannot touch a reserve or a share balance. Even fully compromised, it can nudge a multiplier within the solvency bound and the 25%-per-update rate cap — it can never move a single wei of anyone's funds.

1. Connect an EVM wallet on Robinhood Chain and pick how much ETH you want to spend.
2. The app quotes you a share count at the listing's current on-chain price, and submits a real transaction for your wallet to approve.
3. The contract moves your ETH into that listing's vault and credits you the matching number of shares in its ledger, against your address.
4. A minimum-shares guard protects you if the price moves between the quote and your approval — the transaction simply fails rather than filling at a worse price.

Shares are always whole numbers — SHARPS doesn't do fractional shares. Any leftover ETH that doesn't divide evenly into a whole share is refunded to you in the same transaction, not absorbed.

Selling burns your shares and pays you ETH out of that listing's reserve, at the full curve price, minus the 2% sell fee. You walk back down the same curve you bought on, so each share you sell fetches slightly less than the one before it.

This is the main thing that changed from the earlier design, and it's worth being explicit about: the old model quoted one price and paid min(quote, pro-rata backing), meaning a thin listing could hand you less than the screen said at the moment you sold. That cannot happen now. The cost of that guarantee is the fee, and the fact that a rising score lifts price only as fast as the reserve can back it.

Selling reduces supply, so the price steps down for remaining holders — exactly the mirror of your buy stepping it up.

Price, chart, and market cap are served from a single shared feed, rebuilt from the contract's own on-chain events by an indexer, and pushed to every connected browser in real time.

That matters because people trade against each other here. An earlier version had each browser poll the chain on its own timer and record its own price history locally — which meant two people looking at the same listing could genuinely see different charts, and a new visitor saw a flat line until their own session had been open long enough. That's replaced.

The chain remains the source of truth. The feed is a queryable mirror of it, and can be rebuilt from scratch by replaying events, so it can't drift into being its own separate version of reality.

The contract (on Robinhood Chain)

Holds every listing, every reserve, and every share balance. Buys, sells, and score updates are all real transactions against it. It is the only thing that can move funds.

The scoring pipeline (off-chain)

Reads each tracked wallet's history from the chain via a public explorer API, reconstructs realized PnL and win rate, ranks the field, and pushes the resulting scores on-chain with a narrow oracle key.

The indexer (off-chain)

Watches the contract's PriceUpdated events and writes them to a shared database, which every client reads. Idempotent: replaying the same events can't duplicate history.

This app

Reads the shared feed for display and talks to the contract directly for trades. It never custodies anything.

There are two privileged keys, deliberately separated so that neither is a single point of total failure.

Admin key

Can create listings, pause the market or an individual listing, and rotate the oracle key. Cannot withdraw, redirect, or otherwise touch funds in any reserve.

Oracle key

Can only push scores. Cannot touch a reserve or a share balance. Its effect is bounded by both the solvency cap and the 25%-per-update rate limit.

No function in the contract lets anyone — admin, oracle, or otherwise — withdraw from a listing's reserve outside of a normal sell by the shareholder.

SHARPS runs on real-world session windows — Asia, London, and New York — rolling through the day from 00:00 UTC to 21:00 UTC on weekdays. Prices keep updating whenever the overall market is open, and trading is closed outside those hours and on weekends.

The oracle score refreshes on its own cadence (roughly every 20 minutes) independent of session state, so a listing's tracked performance stays current even between trades.

SHARPS works with any standard EVM browser wallet (MetaMask, Rabby, Coinbase Wallet, and others) — click Connect Wallet in the header and approve the connection. No account, email, or signup required.

The app defaults to Robinhood Chain testnet (chain ID 46630) unless explicitly configured for mainnet (chain ID 4663), so a missing setting can never quietly point you at real funds. The network is always shown in the header and site footer. Testnet ETH has no real-world value and is only for testing.

If your wallet is connected to a different network, the connect button says so and offers to switch — rather than letting a trade fail with an unexplained error.

• Not financial advice. Nothing on this site is a recommendation to buy or sell anything. Trader performance is not indicative of future results.
• Sell payouts can be capped. See Selling shares — an undercollateralized listing pays out less than its quoted price.
• Admin controls exist. A contract admin key can pause trading market-wide or on an individual listing, and can create new listings. It cannot access, redirect, or withdraw funds from any vault.
• On-chain, irreversible. Every buy and sell is a real Robinhood Chain transaction. Once confirmed, it cannot be undone.
• Unaudited contract. The SHARPS contract has not been through a third-party security audit. It holds user funds. Treat it accordingly and don't commit more than you're willing to lose.
• Identity is best-effort. Trader names, avatars, and X links are sourced from public wallet-tagging data and are not proof that a wallet belongs to a given person. Verify the address yourself before trading on a name.

Listing

One tracked trader wallet, tradable as a stock with its own ticker.

Share

A unit of a listing, held in the contract's ledger against your address. Whole numbers only.

Perf score

0–100, that trader's rank against the whole field. Relative, so it moves when standing moves.

Multiplier

What the score does to the price. 1× at score 50; higher lifts the curve, lower drops it.

Curve

Each successive share costs more than the last. Buying walks price up, selling walks it down.

Reserve

The ETH backing one listing, held by the contract. Kept equal to the curve value of all outstanding shares.

Backing / share

Reserve divided by outstanding shares — the money actually behind each share.

Market cap

Price × the 10,000,000 share cap. A comparability figure, NOT money in the listing.

Price lags score

The score wants a higher price than the reserve can back yet. Shown, not hidden.

Oracle

The narrow key that pushes scores on-chain. It cannot move funds.