Hedgefun Protocol v1
The first strategy-token launchpad for tokenized stocks.
Pick a stock. Write a strategy. Launch a Hedgefun.
Pick your ticker, write your strategy — five numbers — and send it. What comes back is a token whose treasury trades that real stock by your strategy, forever, and spends its profit buying the token back and burning it. The creator gets paid out of every sell, in the stock, for as long as it runs.
No capital required: the entire supply seeds the pool as one-sided liquidity that stays there permanently. No manager, no keeper, no key, and no permission — your strategy is public before anyone buys, and frozen the moment it launches.
A launched one is a Hedgefun. The contracts call it a strategy — strategies(id), strategyCount — so
that is the word in the ABI and on the integration page; on this page, the strategy is the rule and the Hedgefun
is the thing it runs.
New here? How it works draws the machine and runs a strategy through six kinds of market; who does what covers the holder, the trader, the creator and the keeper.
Public launching is open on Robinhood Chain, twelve stocks are listed, and the first Hedgefun is trading.
Read on chain 2026-09-22: publicLaunch is true, strategyCount is 1. Addresses are below.
Key facts
- The token trades against its stock, in its own Uniswap V4 pool.
- Buy tax burns. Sell tax — paid in the stock — funds the treasury, the creator and the protocol.
- Launch liquidity is permanent. Nothing graduates, nothing migrates.
- A launched token has no owner: strategy, rates and liquidity are fixed. The protocol keeps four bounded powers, and none of them reach a treasury's money or its strategy.
- A holder's link to the treasury is the buy-back and burn. There are no shares, so no NAV and no redemption.
The desk is at hedgefun.trade, on its own registrable domain, so an app where
people sign transactions never shares an origin with token names strangers chose. hedgehood.app�5� is a
page about it and a link to it. The domains we run are �4�, hedgehood.app and
docs.hedgehood.app — anything else wearing this design, however close the spelling, is someone else's.
Deployments
Chain 4663, Robinhood Chain. Deployed from commit 3dc07eb and frozen.
Core contracts
| contract | address | what it is for |
|---|---|---|
HedgeFunFactory | 0x58F6Ced8d02cD2567f1458801440Bc4eb67fA961 | Launches strategies, and holds the record of every one (strategies(id)) |
HedgeFunHook | 0x2A16d0973385952cFBE750D37f803d0958472844 | The single Uniswap v4 hook every Hedgefun pool runs on: the tax, and its collection |
HedgeFunTradeRouter | 0xb281F7D91325A3A386A00cA0F6010BC8B1491c8C | Buy and sell a Hedgefun's token with USDG |
HedgeFunLaunchRouter | 0x470F5DeB0897118F6575F72183781C6a0610E1FA | Launch with a first buy or a seed, in one transaction |
TradingCalendar | 0xFE9E85f0C258Fc2757eB6Acd1ca032Ec860487F5 | The market calendar, and the emergency brake |
TreasuryDeployer and TokenDeployer, which the factory calls, are in
integration with the deployment commit and verification state.
Governance
| address | |
|---|---|
| Protocol multisig (Safe, 3-of-4) | 0x2910117dd2cB431173Ae9Fb6eAF30726321d1693 |
Created per Hedgefun
Read from factory.strategies(id), which returns (token, treasury, hook, stock, creator). The first one:
| address | |
|---|---|
The token (HedgeFunToken) | 0xF5501c0D85992dD59371e15e3e7b60654ebaF332 |
Its treasury (HedgeFunTreasury) | 0xc21873529515990C80BACe0931141e6B9D5A4fe0 |
Supported stocks
Twelve, each with the oracle and V3 pool the listing fixes. Verified on chain 2026-09-22.
| stock | stock token | price oracle |
|---|---|---|
| NVDA | 0xd0601CE157Db5bdC3162BbaC2a2C8aF5320D9EEC | 0x03c77f527Aa1B0B304602e3fB9Ac994dd1c157f8 |
| SPCX | 0x4a0E65A3EcceC6dBe60AE065F2e7bb85Fae35eEa | 0xC109426706b9D01719ED82e8cd027fA91fBcdC0b |
| CRCL | 0xdF0992E440dD0be65BD8439b609d6D4366bf1CB5 | 0x3bd2c093948D38A5eC2D945C5b065e5Db89aaB36 |
| GOOGL | 0x2e0847E8910a9732eB3fb1bb4b70a580ADAD4FE3 | 0x15400359B0D14B4151FAe80b837abF3fA1977256 |
| AMZN | 0x12f190a9F9d7D37a250758b26824B97CE941bF54 | 0xb34d278D2c792B7C48252C5eB8130Db45e35294e |
| GME | 0x1b0E319c6A659F002271B69dB8A7df2F911c153E | 0x7548A343D06E45507Dd8F546D9d9Fdf684575ecE |
| META | 0xc0D6457C16Cc70d6790Dd43521C899C87ce02f35 | 0x699E34068b8975bE113eD5fF12e429c69BCf1011 |
| USAR | 0xd917B029C761D264c6A312BBbcDA868658eF86a6 | 0x02dE419166CED89fc9FCe2687CdBcBbc9eDe2612 |
| MSTR | 0xec262a75e413fAfD0dF80480274532C79D42da09 | 0x19d0328F3152d1361db7B3Dd7708Cc36A779d612 |
| AMD | 0x86923f96303D656E4aa86D9d42D1e57ad2023fdC | 0xc809bDf7E31E4830de2b03e6f809869Fb99f2246 |
| MU | 0xfF080c8ce2E5feadaCa0Da81314Ae59D232d4afD | 0x4D15A4A1028f001800774A3d2DC31d77945399a4 |
| INTC | 0xc72b96e0E48ecd4DC75E1e45396e26300BC39681 | 0xd399113f3196044A001614Ca9dda9cD8c9424264 |
Each row is listings(stock), which also returns the V3 pool and the opening price — read it from the factory
rather than from this page.
Launches
CRCLGRID — Hedgefun CRCL Range Grid
The first one, launched by the protocol multisig on 2026-09-22 at 08:48 UTC, block 69,523,800.
CRCLGRID was launched by the platform as an initial test. We consider its launch setup a failed experiment: it did not include two-sided liquidity, and its treasury started with no USDG dip-buying reserve.
Under its configured rules, the treasury must first reach the +20% take-profit level on a booked stock lot and execute that sale before the recovered principal can fund the USDG reserve. Until then, even a 15% dip does not give the treasury money to buy. With no stop-loss, if no lot reaches its first take-profit level and no USDG reserve is added, the strategy may never execute a stock sale or a dip buy. It can miss a market bottom entirely.
This limitation concerns the treasury's strategy trades; the first take-profit level is not a condition for holders to sell CRCLGRID in its token pool.
| Token | 0xF5501c0D85992dD59371e15e3e7b60654ebaF332 |
| Treasury | 0xc21873529515990C80BACe0931141e6B9D5A4fe0 |
| Stock | CRCL, 0xdF0992E440dD0be65BD8439b609d6D4366bf1CB5 |
| V4 pool id | 0xfe98797b4dc2e5008712f812f3d90acba5adb216f8aa32e412fa377fb90b0b64 |
| Launch tx | 0x9a0c0240e9d2172440b70968294896a2b236e42ebf717fe781262b5666a1ca82 |
| Tax | 10% each side, flat rate now live |
| The strategy | take profit at +20% then +40%, buy a 15% dip with 20% of the reserve, no stop — every lot sells above its cost |
| Staleness band | 10 bps/hour, the ceiling the owner set for CRCL |
Read on chain 2026-09-22: supply 999,020,555 of 1,000,000,000 — 979,444 tokens already burned — one lot
booked, 0.068 CRCL in the treasury, health() true at 95.68 USDG per CRCL. Read them live rather than from this
page.
How a launch works
1 · Pick a listed stock. The oracle and the pool come with the listing, which is what makes the price one nobody involved can steer.
2 · Write the strategy. Name, symbol, tax rate, your own cut of it, and five numbers: tp1, tp2, dip,
stop, lotBps. Supply, opening price, execution bounds and the protocol's cut are fixed by the factory.
3 · Launch. One transaction deploys the token and the treasury, opens the <token>/<stock> V4 pool and seeds
the entire supply into it. launch carries the hash predict returned, so you get exactly the terms you
were quoted.
4 · Optionally, in the same transaction, take your first buy, hand the treasury its first stock, seed a USDG dip reserve and write the token's page — logo, description, five links. What goes into the treasury stays there.
The flywheel
Five stations, one loop. People trade the token; every trade is taxed; the sell side buys real stock and the buy side burns; your strategy works that stock; the profit buys the token back and burns it; there is less of the token than there was. Then someone trades again.
Anyone can be the quant. An opinion about one stock, and five numbers to express it. The strategy is public before anybody buys and frozen at launch — which is exactly why a stranger can back it.
A strategy that works pays its author. Every sell hands the creator a cut, in the stock itself, forever. Burn supply, keep the book busy, and the wheel keeps paying the person who wrote it.
The same loop, as wiring
Two burns, two sources: a buy burns its own tax on the spot, and a profitable sale burns tokens the treasury had to buy first.
The tax
| charged in | where it goes | |
|---|---|---|
| Buy | the token | burned, less a 0.5% tip to whoever calls the sweep that settles it |
| Buy, first 3 seconds | the token | 99% → 66% → 33% → flat. The premium burns with the rest |
| Sell | the stock | sweep tip · protocol · creator · the treasury |
| Sell, at launch and after each buy-back | the stock | the same split, spiked, decaying linearly back to flat |
Two things a front end has to get right:
- Quote the live rate —
buyRateBps/sellRateBpsfor that pool. In the opening seconds the flat rate is off by as much as 99 points. - Show what the launcher took. Buys made inside the launch transaction are exempt from the window and uncapped: measured on the frozen contracts, 80,000 of the stock took about 90% of the supply at the flat rate, in the same second a stranger's identical buy paid about 1%. That number belongs on the page.
The launch window turns the first three seconds into a falling-price auction rather than a latency race.
Exact-output is accepted for a flat-rate buy, taxed on the stock going in and grossed up so the route costs the same. Sells are exact-input, because V4 taxes the unspecified leg and on an exact-output sell that leg is the input — taxing there would burn the tax the treasury is meant to receive.
The protocol fee, and what it has to do with $HEDGE
A protocol earns from what runs on it. Here that is one line of the sell tax: after the sweep tip, 20% of it goes to the protocol, in the stock, and the rest splits between the creator and the treasury. Buys earn the protocol nothing — a buy burns.
It is paid to protocol on the factory, which reads
0x2910117dd2cB431173Ae9Fb6eAF30726321d1693 — the same multisig that owns the factory. Protocol revenue lands in
the protocol treasury, not in a company wallet and not in any launch's treasury.
$HEDGE is a separate pot, and stays one. The trading tax on $HEDGE keeps going where it goes today: to $HEDGE holders, on the $HEDGE page's own schedule. No Hedgefun launch pays $HEDGE holders, and $HEDGE's tax pays nothing to Hedgefun. Two revenues, two audiences, no plumbing between them.
What the protocol treasury does with its side is a decision, not a mechanism. If it earns enough, buying $HEDGE back is on the table — the multisig would do it, in public, when the numbers justify it. There is no contract that routes Hedgefun revenue into $HEDGE, no schedule, and nothing here that promises a buy-back will happen.
The strategy
Sell tax arrives in the stock and is booked as a lot at the oracle price. From there it is mechanical, and every step is a public call that pays a bounty to whoever makes it:
| call | what it does |
|---|---|
book() | costs arriving stock as a lot, at the live oracle price |
takeProfit(lot) | sells part at cost + tp1, the rest at cost + tp2. Principal returns as USDG, profit stays in stock |
stopLoss(lot) | if the creator set one, sells below cost. It burns nothing |
buyDip() | after a fall of dip from the last sale, spends reserve on stock, as a new lot |
buyback() | spends accumulated profit on the token in its own pool, and burns it |
A lot sells above its own cost, with a creator-set stop as the single exception. So realised profit stays positive, and a flat market leaves the treasury waiting rather than selling down.
Why it runs, when nobody is running it
There is no keeper and no key. Every call above is open to everyone, checks its own trigger against the oracle,
and either fires or answers false. So the question is never who is trusted to run the strategy — it is who gets
there first, and the answer is whoever wants the bounty:
| call | the bounty, and what it is paid in |
|---|---|
takeProfit | a cut of the profit, in the stock |
stopLoss | a cut of the proceeds, in USDG — a stop has no profit to pay from |
buyDip | a cut of what was spent, in USDG, taken off the spend rather than the ask |
buyback | a cut of the tokens bought, in the token. The rest burns |
| the hook's sweep | a separate tip of whatever that sweep distributes |
The cut is bountyBps: 0.5% as shipped, 2% at the contract's ceiling. book() pays nothing by itself — it is
the free call that makes the paid ones possible, so it rides along in the same bundle.
The price reaches a target and the transaction is suddenly worth money, so somebody sends it. The price is
nowhere near and the call answers false for the cost of the gas. That is the entire scheduler — nothing to
pause, nobody to pay, no key to lose. And the caller never picks the price: the trade executes against the pool
inside the oracle-derived bound, so all they choose is when to ask.
tp1 and tp2 are uncapped. A 100× target means the treasury sells only there — and until it does there is no
profit, no buy-back and no burn, and nothing refilling the dip reserve. Read a launch's targets before its story.
The treasury starts empty and fills from turnover: stock arrives as sell tax, USDG as realised profit, so
dip-buying comes after the first take-profit. A creator who wants ammunition on day one just sends it — stock
sits unbooked until anyone calls book(), and USDG is the dip reserve. It stays in the treasury.
A sale fills as far as the oracle price less the slippage limit allows: the pool computes its own depth, the lot gives up only what sold, and one call offers at most a sell chunk the owner sizes per listing.
Three numbers, and what each one measures
A launch shows three figures that look alike. Each is measured from somewhere different.
Market FDV — the pool's marginal price × a stated supply. The opening FDV is a stock-denominated
parameter: the default supply is 1,000,000,000 tokens and NVDA's listing opens at 4.42e-8 stock per token, so
a launch on NVDA opens at 44.2 NVDA — about $10,000 when NVDA printed $226.14, and it moves with the stock.
Say which supply you used, issued or issued-less-burned, and net the burn exactly once.
Stock in the pool — what that Hedgefun's own pool holds right now, with a reference value at a stated price
and time. The token side is reported beside it as a count. The per-pool figure comes from the pool's own state:
every V4 pool on the chain keeps its balances in the shared PoolManager, so balanceOf(PoolManager) is all of
them at once. What a sale realises depends on size, position in the range, slippage and the sell tax.
Treasury assets — the stock and USDG the treasury holds, split into principal, realised profit and the buy-back budget. Those are stages of one pile, so they are reported side by side rather than summed, and the pool and the treasury are separate pots. A treasury valuation divided by supply is not a redemption price; the treasury's route to a holder is the buy-back and burn.
When a figure has not been read, the page says not fetched, carries its price source and read time, and flags a stale feed — the feeds are 24/5, so stale on a weekday evening is the normal state. Rehearsal numbers belong in dated examples.
Two pools, two jobs
The token's own pool is Uniswap V4, on the shared hook, always. The treasury's stock leg is Uniswap V3, with a ten-minute TWAP corroborating spot — V3 keeps the observations a closure-time price needs, and a pool whose observation ring is too short for the window is refused at construction.
Listing therefore follows depth on V3, which is why the first batch is twelve names rather than the whole registry. More arrive as their venues qualify.
The token trades all week; the stock leg keeps market hours
New stock is booked at the next open, at the opening price. A listing may allow bounded work during a closure
through a staleness band, which the creator picks at launch from 0 up to a per-stock ceiling the owner
sets. The band widens how far spot may sit from the last Chainlink print before the treasury pauses; the trade
still executes against the oracle-derived bound, so a wider band buys tolerance, not a better price. It is frozen
at launch like the rest of the strategy.
Everything in the three prices applies: RHxxx / USD naming, the multiplier already included in the
answer, 24/5 feeds, and oraclePaused() during a corporate action. The oracle fails closed on all of it.
Liquidity that stays
V4 keys a position to who called, which ticks, and a salt. For the seed the caller is the factory, from inside its own callback — and the factory's bytecode has no function that calls back at that key under any name. Proven against the real V4 PoolManager by handing a test contract the exact ticks and liquidity the factory used: the position stays put. True for the creator, for the protocol, and for everyone else.
What the protocol holds
The factory's owner is a Safe. Against a launched Hedgefun it holds four powers:
- Halt trading through the calendar, for a closure no strategy predicts — a day of mourning, a hurricane. It can stop a Hedgefun trading on any day, and the price it trades at stays the oracle's.
- Move its own payout address for a pool. Its own money, no delay.
- Move the payout of a creator who has vanished — 14 days after proposing it on chain, and one call from the creator ends it and bars a new proposal for 180 days. That call doubles as proof of life.
- Point the treasury's votes at a delegate. It moves no asset and touches no rule. It is reserved for the day a stock issuer opens a delegate surface: the stock token is upgradeable by its issuer while a launched treasury is not, and a hatch missing at birth can never be added.
For future launches the owner also sets listings, factory defaults, band ceilings, execution gates, the sell chunk, which periphery may launch on a creator's behalf, and whether launching is public. All of it applies to launches yet to happen. The token's page — logo, description, links — belongs to whoever launched it.
Roadmap: holders vote the treasury's shares
The vote seat exists in v1 and reads its holder live from the factory, so it can become a contract where a token's holders choose the delegate — with no treasury changing and nothing already launched migrating. Reserving it now is the whole reason the seat is there. It goes live the day an issuer opens a delegate surface for tokenized stock.
What it covers is the stock's own corporate governance: how the shares a treasury holds get voted. The treasury's money, its strategy and its buy-backs stay fixed at launch, and a holder's link to the treasury stays the buy-back and burn.
What you are taking on
-
The treasury is long one stock. It works when that stock moves, and waits when it does not.
-
Turnover funds everything. Trading pays the tax that fills the treasury and drives the burns.
-
A high target sells rarely, so burns can be sparse for long stretches.
-
The stock token is upgradeable by its issuer, who can pause or deny-list transfers; a treasury's holdings depend on that token.
-
The launcher's first buy is uncapped. Check what they took before you buy.
-
Reviewed, and an audit is under way. Nine internal review rounds plus two external reviews, no Critical, High or Medium finding outstanding, over a thousand tests including fork tests against real chain state. The audit report is not published yet, and the hook and a launch are immutable once live.
-
A launch is not an endorsement by the stock's issuer, by the protocol, or by anyone. Anyone may launch on any listed stock under any name.
-
Legal status is unassessed. A token whose treasury accumulates tokenized equities has not been reviewed by counsel.
-
It is not open to everyone. Hedgefun is closed to U.S. persons, to comprehensively sanctioned places, and to anywhere dealing in this would be unlawful — see who may not use it.
This is an interface, not investment advice, and nothing here is an offer to sell or a solicitation to buy anything. Despite the name, a Hedgefun is not a fund: no shares, no net asset value, no redemption, no manager. See the Terms of Use.