# Hedgefun Protocol v1

Source: https://docs.hedgehood.io/hedgefun

**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](https://docs.hedgehood.io/hedgefun/how-it-works) draws the machine and runs a strategy through six kinds of
market; [who does what](https://docs.hedgehood.io/hedgefun/roles) covers the holder, the trader, the creator and the keeper.

:::info[Live]

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](#what-the-protocol-holds), 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](https://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](https://docs.hedgehood.io/hedgefun/integration#production-addresses) 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.

:::warning[Platform test — failed launch setup]

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

![The Hedgefun flywheel: anyone writes a strategy, the machine trades a real stock by it forever, every trade is taxed, the treasury works that stock, profit buys the token back and burns it, and the strategy's author is paid a cut of every sell.](https://docs.hedgehood.io/img/flywheel-en.svg)

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.

<details>
<summary>The same loop, as wiring</summary>

```mermaid
flowchart TD
  BUY["Someone BUYS the token"] -->|tax charged in the TOKEN| TBURN["Burned<br/>(less a 0.5% tip to whoever swept it)"]
  SELL["Someone SELLS the token"] -->|tax charged in the STOCK| SPLIT{"split four ways"}
  SPLIT --> TIP["sweep caller's tip"]
  SPLIT --> PROTO["protocol"]
  SPLIT --> CREA["creator"]
  SPLIT --> TRE["the treasury"]

  TRE -->|"book() — costed at the oracle price"| LOT["a LOT"]
  LOT -->|"cost + tp1, then cost + tp2"| SALE["sold"]
  SALE -->|"the PRINCIPAL"| RES["USDG reserve"]
  RES -->|"buyDip() — last sale −dip"| LOT
  SALE -->|"the PROFIT, still in stock"| BB["buys the token back<br/>in its own pool"]
  BB --> PBURN["Burned"]
```

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**.

</details>

## 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` / `sellRateBps` for 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

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.

## 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*.

:::caution[A high take-profit sells rarely]

`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](https://docs.hedgehood.io/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:

1. **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.
2. **Move its own payout address** for a pool. Its own money, no delay.
3. **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.
4. **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](https://docs.hedgehood.io/terms#3-eligibility-and-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](https://docs.hedgehood.io/terms).
