How SHARPS works

Every listing on SHARPS is tied to a single, real wallet on Solana — 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 program directly, your shares are recorded in a position account the program keeps for your address, and the SOL behind every listing sits in that listing's own on-chain account — not in a company account.

Price, chart, and market cap are served from one shared feed rebuilt from the program'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.

Everything on SHARPS happens on Solana: the traders being priced trade there, their performance is read from there, and every share is bought and sold there. Nothing is bridged, wrapped, or held off-chain.

Currency

Every price, trade, fee and payout is in SOL.

Speed

Trades confirm in a second or two, at any hour.

Network fee

About 0.000005 SOL per transaction — a fraction of a cent.

The market itself is one Solana program — the on-chain code that holds each listing's SOL, sells and buys back shares, and splits fees. It is public, so you can inspect it and every transaction it has processed on Solscan: 5HVwtd2UXjn9q1v8L3zV4iidkopPUXGyXntbnQzgR1Ei.

Each listing has a ticker (like $COOK), a name, and a linked wallet address you can verify yourself on any Solana explorer. A listing exists on-chain once it's been created by the program 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.

245 of the 246 listed traders have a name, avatar, and linked X account. One is 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 lamport paid in stays in that listing's own reserve, and the reserve is never allowed below 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 program, and the program 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 lamport of anyone's funds.

1. Connect a Solana wallet and pick how much SOL 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 program moves your SOL into that listing's reserve and credits the matching number of shares to your position account.
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. Only the exact cost of the whole shares you receive leaves your wallet — the remainder of the amount you entered never moves. Your first buy of a listing also pays a small, one-off account rent (about 0.0014 SOL) for your position account.

Selling burns your shares and pays you SOL 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 program'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 program (on Solana)

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 swaps from Solana via an RPC indexer, 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 program'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 program 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 program lets anyone — admin, oracle, or otherwise — withdraw from a listing's reserve outside of a normal sell by the shareholder.

Solana never closes, and neither does SHARPS: you can buy or sell any listing at any hour, every day. The Asia, London and New York session windows shown in the header are context only — they tell you which trading day is awake, and never block a trade.

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 Solana browser wallet (Phantom, Solflare, Backpack, and others) — click Connect Wallet in the header and approve the connection. No account, email, or signup required.

This build is connected to Solana Devnet. Devnet SOL has no real-world value; nothing here is real money. The app only reaches mainnet when it is explicitly configured for it, so a missing setting can never quietly point you at real funds. The network is always shown in the header and site footer.

To trade you need SOL in that wallet — buy it on any exchange and send it to your wallet's address. Keep a little extra for network fees and, on your first buy of a listing, the one-off rent for your position account (about 0.0014 SOL).

Your wallet must be on the same network as this build. For devnet, switch it in the wallet's own settings (in Phantom: Settings → Developer Settings → Testnet Mode).

• Not financial advice. Nothing on this site is a recommendation to buy or sell anything. Trader performance is not indicative of future results.
• Admin controls exist. A program 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 reserve.
• On-chain, irreversible. Every buy and sell is a real Solana transaction. Once confirmed, it cannot be undone.
• Unaudited program. The SHARPS program 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.

SOL

Solana's currency. Every price and payout on SHARPS is in SOL.

Lamport

The smallest unit of SOL: 1 SOL = 1,000,000,000 lamports.

Program

The on-chain code that runs the market. It holds every listing's SOL and executes every trade.

Position account

A small on-chain account that records how many shares of one listing your wallet holds.

Share

A unit of a listing, held in your position account on the program. 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 SOL backing one listing, held in its on-chain account. Never below 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.