Hookdaq

The stock market's launchpad. Zero-seed Uniswap v4 pools on Robinhood Chain, quoted in ETH or 200+ Robinhood Stock Tokens.

[Hookdaq @Hookdaq]

Introducing Hookdaq: The First Launchpad That Quotes Tokens in Real Stocks and Pays the Ecosystem Back.

CA: 0x15eae4a2526d109408c7f919e4bb592d68c42908

Robinhood put the stock market on-chain. Then we built a place where those stocks are the money.

Hookdaq is a token launchpad on Robinhood Chain, built on canonical Uniswap v4. Every launch opens a zero-seed pool for a brand-new token, quoted in ETH or in any of 200+ Robinhood Stock Tokens - NVDA, TSLA, SPY, AAPL. Creator fees, pot payouts and burns all account in that stock. The rules are frozen before the first swap, enforced by the hook, not by promise.

Full Hookdaq Breakdown Below:

[Hookdaq @Hookdaq]

A seed round before the chart even exists. A launch that starts long before your community gets a chance to trade.

Hookdaq takes a different approach.

Zero seed. An instantly live pool. Rules locked before the first trade.

Go from creating your token to opening its market, with clear terms from day one and no post-launch changes.

Choose your quote asset. Launch your token. Let your community take it from there.

Launch on Robinhood Chain.

[Hookdaq @Hookdaq]

Imagine a community token quoted in $NVDA, with Auto Burn and an Nth-buy Pot.

The quote asset and launch mechanics each play a different role in how that market works.

Buyers trade using tokenized $NVDA. With Auto Burn enabled, a configured share of the token output from each buy is burned, reducing the amount the buyer receives.

At the same time, a configured share of qualifying buy inputs builds a pot denominated in tokenized $NVDA.

Every Nth qualifying buy credits the accumulated pot to its recipient, who can then claim it. The counter is public and deterministic, so participants can follow its progress and understand the rules.

Creator fees accrue in tokenized $NVDA too, connecting the creator’s earnings to the same asset used for trading.

Together, these choices give the market its own structure: a stock-token quote asset, a supply-reduction mechanic, and a recurring pot payout.

The creator configures the mechanics before launch. Once the pool goes live, those settings are locked.

That is what makes combining launch mechanics interesting. Each choice affects the trading experience, and the pieces need to make sense together.

One community. One market. A setup built with intention.

[Hookdaq @Hookdaq]

The interesting question is no longer just “What token should I launch?”

It is “How should this token’s market work?”

The name gets attention. The ticker gives people something to rally around. But the mechanics shape what happens when trading begins.

Hookdaq’s Builder brings those decisions into one workspace.

Choose ETH or a supported tokenized stock as your quote asset. Configure mechanics like Anti-Snipe, Auto Burn, and the Nth-buy Pot. Review how your choices fit together before committing to the launch.

Every setting has a purpose and a tradeoff. An opening buy cap affects early trading. A burn changes the token output buyers receive. A pot gives qualifying buys another mechanic to participate in.

You do not need every option. You need a setup that fits your idea and that your community can understand.

Once launched, the pool’s configuration is locked. That makes the work you do before the first trade matter.

A token’s behavior deserves as much thought as its branding.

Build your market with intention.

[Hookdaq @Hookdaq]

Memecoins are moving beyond ETH pairs.

With Hookdaq, you can launch a token against tokenized stocks and let your community trade it against $SPY, $NVDA and more.

The culture of memecoins meets the assets people already follow.

More choice for creators. New trading pairs for communities. A new way to bring tokens and traditional markets together onchain.

Choose your quote asset. Launch your token. Build your community.

Hookdaq is where memecoins meet real markets.

[Hookdaq @Hookdaq]

Hookdaq lets you launch a token quoted in ETH or the tokenized stocks people already trade onchain.

Choose the quote asset that fits your community and give your token a market from day one.

No seed round. No hidden games after launch.

Your community trades. You earn in the quote asset you chose.

Launch in ETH, earn ETH. Launch against $SPY or $NVDA, earn in that asset.

$SPY, $NVDA, ETH and more.

Your token. Your community. Your choice of quote asset.

https://t.co/i3qkxAOLst

[Hookdaq @Hookdaq]

20 pools launched on Hookdaq.

Every launch, test, and swap has helped us validate what a better launchpad can look like: transparent rules, configurable pools, and no need to force every project into the same template.

Thank you to every builder and trader who has been early with us.

This is just the start. More pools, more experiments, and more ways to launch.

[Hookdaq @Hookdaq]

Most launchpads make every launch look the same: a fixed curve, fixed fees, and no real control over how the opening behaves.

Hookdaq is built differently.

With Uniswap v4 Hooks, we can attach transparent, onchain behavior directly to every pool, while still settling through Uniswap v4 liquidity.
That means each launch can be configured with modular blocks such as:
• Anti-Snipe - cap early buys per block and add a temporary snipe tax
• Nth-Buy Pot - route part of buys into a public, claim-backed prize
• Auto Burn - automatically send a chosen share of buy output to be burned
• Halt Guard - pause buys when a stock quote is stale or the sequencer is down

Each block has bounded parameters. Builders choose the rules, tune them before launch, and share the exact configuration for anyone to inspect.
No hidden intervention. No opaque custom contracts. No “trust us” launch mechanics.

Just one transparent starting price, configurable protections and incentives, and rules enforced by the pool itself.

That is why Hookdaq is a better launchpad: your launch should not be forced into one template.

Launch Now: https://t.co/TBBem5wLEV

[Hookdaq @Hookdaq]

Building Hookdaq is a long-term commitment.

To reinforce that, we’re burning the 1% allocation acquired by the developer at launch.

Thank you to every project that has launched on Hookdaq and everyone who has tested the product so far. Your feedback and usage are helping us improve it every day.

We’re here to keep building.

TX Hash:
https://t.co/SaLwlFSYsS

[Hookdaq @Hookdaq]

Why the Hookdaq flywheel is smart, and not just another "buyback and burn".

Most flywheels are a promise: fees go to a multisig, and someone buys the token back when they feel like it. Hookdaq's is a set of constraints. Here are the five that matter.

1. The protocol never holds its own token.
$HOOKDAQ was launched outside Hookdaq. The protocol does not mint it, does not hold it, does not sell it. There is no team allocation to dump and no treasury bag to worry about. The only thing Hookdaq can ever do with $HOOKDAQ is buy it and destroy it.

2. Fees are collected in ETH, not in $HOOKDAQ.
Every buy and sell on an ETH-quoted pool pays 30 bps in ETH. The burner buys with real ETH from real volume, so demand for $HOOKDAQ comes from activity on the launchpad, not from a tax on $HOOKDAQ itself. No reflexive loop, no death spiral built in.

3. ETH that enters the burner has exactly one exit.
The Flywheel Burner has no withdraw function. Not for the owner, not for anyone. Once ETH is inside, the only code path that can move it is buybackAndBurn, which swaps it through the ETH / $HOOKDAQ pool and sends the output straight from the PoolManager to 0xdead in the same transaction. Nothing ever sits in a wallet between the buy and the burn.

4. The target cannot be swapped later.
The pool key is set once with configure(). A second call reverts AlreadyConfigured. The owner cannot later point the burner at a different token or a friendlier pool.

5. Anyone can feed it, and the buyback is bounded.
sweepProtocolFees(quote) is permissionless: anyone can push accrued fees into the burner, so the owner cannot sit on them. Each buyback is capped in ETH per call, limited to one per block and protected by a minimum-out floor, so it cannot be front-run into a bad fill and a compromised key cannot drain the burner in one block.

Every buyback emits Burned(ethIn, hdqBurned). totalEthSpent and totalBurned are public counters. The $HOOKDAQ page shows the burner balance and the burn history, straight from the chain.

That is what smart means here: not clever tokenomics, but a machine with fewer ways to cheat than the person running it would have.

[Hookdaq @Hookdaq]

What happens inside one Hookdaq swap. The diagram from the docs, top to bottom.

A buy pays its fees before the AMM sees the input. A sell pays on the quote it receives. Both end in one HookSwap event. Here is every step in between.

Router. You call buy or sell with a pool key, an amount, a minOut, a recipient and a deadline. The router checks the key points at our hook and the pool is live, rejects an expired deadline or a zero recipient, and pulls the input: ETH as value, a stock token via transferFrom. Then it unlocks the PoolManager and asks for an exact-input swap, with your account and recipient in hookData.

beforeSwap, three gates. PoolNotLive if the pool was never seeded. LaunchLocked if this is still the launch transaction. ExactOutputNotSupported if the amount is not exact-input. One flag decides direction: zeroForOne == quoteIsCurrency0 means buy.

Sell? Zero delta. The hook steps aside and the AMM runs.

Buy? Four blocks in fixed order. Halt Guard asks the registry if the quote is halted; if so, QuoteHalted. Anti-Snipe adds your input to this block's total and reverts OverSnipeCap over the cap. _buyFees computes protocol + creator + pot and the hook mints itself claims for them. Nth-buy Pot advances its counter, at most once per block.

Pool swap math. Uniswap v4 core sees your input net of the hook delta. It never sees the fee.

afterSwap. On a buy, Auto Burn takes its share of your token output from the PoolManager and calls burn() on the token: total supply goes down, not to a dead address. On a sell, the hook takes 30 + 50 bps of the quote out, rounded up, capped, minted as claims.

HookSwap(id, trader, recipient, isBuy, quoteAmount, tokenAmount, feeQuote). One event, both directions, fees read from the hook's own computation and never inferred from pool deltas.

Settle and take. The router checks minOut, pays the recipient, and refunds any input the pool did not consume on a partial fill.

Every red box in the diagram is a revert you can hit on purpose. There is no path where the hook fails quietly and takes your money anyway.

[Hookdaq @Hookdaq]

Proof of work: a stock-quoted launch on Robinhood Chain, start to finish, one transaction, using Hookdaq.

This is a real launch on mainnet, not a testnet and not a mock. The token is a test token, the quote is not: it is NVDA, the Robinhood Stock Token, with its live Chainlink feed.

What The Video Shows:

1. Discover is empty. We click Launch a token.
2. Quote step: 35 stock tokens are registered with a Chainlink feed. We pick NVDA.
3. Blocks: Anti-Snipe, max 0.5% of the opening FDV per block plus a 40% snipe tax for 100 blocks. Nth-buy Pot, 0.5% of every buy, the 500th qualifying buy wins the pot in NVDA.
4. Token: TestRWA, ticker $TESTRWA, fixed 1,000,000,000 supply.
5. Price & fees, read live from the registry: NVDA at $230.24, so the $10,000 opening valuation is 43.43 NVDA for the whole supply, 4.34e-8 NVDA per token. Creator earns 50 bps of every buy and sell in NVDA. Creation fee 0.0002 ETH.
6. Review, then Deploy the pool. One signature.

What the chain says:

Token: https://t.co/p8ElRvW1Mb

Launch TX: https://t.co/8Nzq3SuUuV

One detail worth checking yourself: the UI showed 43.43 NVDA. The chain opened at 43.30 NVDA, 0.3% lower, because the opening tick is floored to a multiple of 60. That is the rounding we document, and it only ever rounds in the buyer's favor.

Rules you can read before you sign. Now you can read them after, too.

[Hookdaq @Hookdaq]

Your creator fee is paid in the stock itself.

Launch a token quoted in NVDA, and every buy and every sell pays you 50 bps in NVDA. Not in a wrapper. Not in points. Not in a token you have to sell first. In the tokenized stock, the same NVDA that trades on Robinhood Chain.

Here is why that works. On Hookdaq the quote is not just the thing people pay with; it is the unit every rule accounts in. The hook takes the fee on the quote side of the swap, before anything reaches the AMM, and books it to your pool's ledger as a claim on Uniswap's own PoolManager. If the pool is quoted in NVDA, the ledger fills with NVDA. Nothing is converted along the way, so nothing can be skimmed along the way.

The same goes for the rest of the stack. Anti-Snipe tax during the opening window lands in your ledger in NVDA. The Nth-buy Pot pays its winner in NVDA. Quote in SPY and it is all SPY. Quote in ETH and it is all ETH. One flag in the pool decides the orientation and every code path handles both.

Claiming is one call, whenever you like, to any address you name. Or transfer the creator NFT and the stream goes with it, accrued fees included.

That is the one thing an ETH-only launchpad cannot do. Its blocks are bound to native ETH, so the best it can offer a creator is ETH and a story about a stock. Hookdaq pays you the stock.

[Hookdaq @Hookdaq]

Proof of work.

34 seconds, one transaction, a live market on Robinhood Chain.

What You See In The Video:

→ Pick the quote (ETH)
→ Freeze the rules: Anti-Snipe (0.5% of FDV per block, 40% tax, 100 blocks) + Nth-buy Pot (0.5% of every buy, the 500th buy wins)
→ Name it, sign once
→ $TEST opens at a fixed $10,000 FDV. 100% of supply in one locked sell band. Zero seed, 0.0002 ETH creation fee.

No presale, no LP to rug, no admin key on a live pool. The rules are on chain before the first buy and they never change.

Verify It Yourself:

TX: https://t.co/98db4FnipT
Pool: https://t.co/z5hBFS5B6l

Launch Yours Now: https://t.co/TBBem5wdPn

[Hookdaq @Hookdaq]

Build your block stack before you launch.

Hookdaq pools have four blocks: Anti-Snipe, Auto Burn, Nth-buy Pot, and Halt Guard. Once a pool opens, its config is frozen forever. So we built a place to get it right first.

The Builder is a canvas, not a contract. Drag a block onto the chassis and it lands in the order the hook actually runs it: Halt Guard, Anti-Snipe, pot, then Auto Burn after the swap. Tune each one with sliders in units you think in: percent, blocks, hours, ETH. Every value snaps to the contract's hard range, so you cannot design a config the chain would reject.

Three numbers update live as you move things. Buy drag: what a buyer loses to rules on the way in, 80 bps base plus the pot share plus the snipe tax while the window is open. Gas: an estimate per block. Warnings: a snipe tax at its 50% ceiling, a pot that fills too slowly for its N, the ways a stack can be valid and still wrong.

Done? Share it as a link. The stack encodes into the URL, anyone with it opens the same design, and edits round-trip between the Builder and the Launch flow.

Nothing is written on chain until you hit launch. No wallet, no transaction, no server. Same validation, same config shape the hook takes, minus the signature.

Design it. Share it. Launch it once, and it never changes.

[Hookdaq @Hookdaq]

How Hookdaq turns "$10,000" into a Uniswap tick. This is the diagram from the docs, in words.

Every pool opens with the whole 1,000,000,000 supply valued at $10,000. Nobody picks a price. The only input is the quote's Chainlink USD feed, and it decides one thing: how many tokens one unit of quote buys at the open.

1. Chainlink answer. The registry reads the quote's USD feed, 8 decimals. ETH at $2,500 → 2,500e8. NVDA at $230 → 230e8. Stale, paused or non-positive: the launch reverts here with a typed error and nothing is minted.

2. Tokens per quote. tokensPerQuote = SUPPLY × usd8 / 10,000e8. At $2,500 one ETH buys 250,000,000 tokens. At $230 one NVDA buys 23,000,000. Same formula for every quote; the registry only admits 18-decimal quotes so it never bends.

3. Orientation. Uniswap prices are currency1 per currency0, and the token's address decides which side it lands on. If the quote is currency0 the price is t; if the token is currency0 the price is 1e36 / t. Every code path handles both. Nothing is hard-wired to one side.

4. Square root, shift, bounds. sqrt(price × 1e18) << 96 / 1e18 gives the raw sqrtPriceX96. If it leaves (MIN, MAX), PriceOutOfRange reverts the launch. It cannot silently clamp.

5. Snap to a tick. The raw price becomes a tick, floored toward negative infinity to a multiple of 60, then converted back with getSqrtPriceAtTick. The pool opens exactly on a tick boundary, which is what a single-sided position needs. Flooring means the on-chain price is at most 0.6% under the exact target, never over.

6. The seed range. Quote is currency0: the position spans [minUsableTick, tick], all tokens above the price. Token is currency0: [tick, maxUsableTick], all tokens below it. Either way the pool holds only tokens at the open. The first buy is the first quote that ever enters it.

7. Initialise and seed. One transaction, zero seed capital, position owned by the LPLocker forever.

One consequence people miss: because the position is single-sided and the LP fee is zero, the opening tick is the floor. Sell everything back and the pool returns to the opening price. It can never show a lower one.

[Hookdaq @Hookdaq]

How the Hookdaq flywheel works, step by step.

1. A fee is taken.
Every buy and every sell on every Hookdaq pool pays 30 bps to the protocol, on the quote side. The hook does not move tokens around; it mints itself a claim on Uniswap's PoolManager and books it in a ledger per quote.

2. Anyone sweeps it.
sweepProtocolFees(quote) is permissionless. Call it and the accrued ETH moves to the Flywheel Burner. You do not have to trust us to do this step; you can do it yourself, any block.

3. The burner buys $HOOKDAQ.
The owner calls buybackAndBurn(ethIn, minHdqOut). The burner swaps ETH through one configured ETH / $HOOKDAQ Uniswap v4 pool. Three bounds it cannot break: ethIn is capped per call, at most one call per block, and minHdqOut is a slippage floor that reverts the whole transaction if the pool gives too little.

4. It burns in the same transaction.
The $HOOKDAQ never touches a wallet. It goes straight from the PoolManager to 0x000…dEaD inside the same call. There is no burn wallet, no "later", no discretion between buying and burning.

5. It is all on-chain.
totalEthSpent and totalBurned are public counters. Every buyback emits Burned(ethIn, hdqBurned). The indexer lists every receipt and the $HOOKDAQ page shows the burner balance, the total burned and the history.

What feeds it and what does not: ETH-quoted pools feed the burner. Stock-quoted pools pay their 30 bps to the treasury for now; routing those into the flywheel is a later phase.

[Hookdaq @Hookdaq]

Developer Update: 35 stock quotes are live, and how the list grows.

What Shipped:
The QuoteRegistry on Robinhood Chain now holds ETH plus 35 Robinhood Stock Tokens: NVDA, MSFT, AAPL, GOOGL, AMZN, META, TSM, TSLA, SPY, ORCL, ASML, PLTR, QQQ, BABA, AMD, MU, INTC, DELL, COIN, MSTR, SGOV, SNDK, SLV, RKLB, CRWV, NBIS, CRCL, GME, IONQ, EWY, USO, CLSK, RGTI, SPCX, USAR. Any of them can be the quote of a new pool today.

How The List Was Built:
We pulled Chainlink's feed list for Robinhood mainnet and kept every stock token that has a USD feed on this chain. Then we checked each one on chain: the token has code, the feed answers a positive price less than 24 hours old, 8 decimals on the feed, 18 on the token. 35 passed. That is not a curation; it is every stock that can be priced.

Robinhood lists 194 stock tokens. The other 159 have no Chainlink feed here yet, and without a feed there is no opening price and nothing for Halt Guard to read. They sit dimmed in the launch picker as "no feed".

How The Picker Knows:
The picker does one batched quotes() read through Multicall3 and tags each token quote, disabled or no feed. Registered tokens are listed first, largest first; the rest are dimmed. The registry is the only source; nothing is hardcoded in the UI.

How a Stock Gets Added:
One owner call: add(token, feed, heartbeat). The registry checks the feed has code and reports 8 decimals, and that the token reports 18. It is append-only. A quote can be closed to new launches, but it can never be removed and its feed can never be swapped, so a pool you launched yesterday does not care what we add tomorrow. The same call never touches a live pool.

What Is Next:
We watch Chainlink's Robinhood feed list. When a feed lands for one of the 159, we verify it the same way and append it. If Chainlink publishes an L2 sequencer uptime feed for the chain, we wire it in with setSequencerFeed and both reads start honouring it. Until then the list grows one verified feed at a time.

[Hookdaq @Hookdaq]

Nth-buy Pot is one of the four blocks you can switch on when you launch a token on Hookdaq. It pools a slice of every buy and pays the whole pot to every Nth buyer. Default: Every 500th buy wins.

Switch it on and the hook takes 0.5% of every buy's quote input into a pool-level pot. Not into a wallet: into a ledger inside the hook, held as a claim on Uniswap's own PoolManager. An NVDA pool fills an NVDA pot.

The counter is public and it advances once per block per pool. A buy has to clear the creator's minimum size to count, so dust buys feed the pot but do not move the line. Two buys in the same block: the first one counts, the second one only pays in.

When the counter hits a multiple of N, the whole pot is credited to that buy's recipient and the pot resets to zero. The win is booked, not pushed. The winner calls claimPot whenever they like and names the address the quote goes to. Nobody can send it anywhere else, including us.

Every step emits an event: PotAdvanced with the count and the address, PotWon with the amount, PotClaimed when it leaves. You can watch the line move on the explorer or through the indexer. The creator picks the share, the N and the minimum once, at launch, and after that none of it can change.

Like every Hookdaq block, it works on every quote. Deterministic, public, raceable. We say that on purpose. If you can see that buy 499 just landed, so can everyone else. That is the game, and it is the same game for every wallet.

[Hookdaq @Hookdaq]

One transaction. Every step can revert, and the whole thing runs under a launch lock.

launch() checks the hook is set and not paused, and that the creation fee is exact. Then it asks QuoteRegistry for a fresh Chainlink price. Stale feed, sequencer down, unknown quote: revert.

Token is deployed with CREATE2, the pool is initialised at the opening price (fee 0, tick spacing 60), the hook registers the frozen blocks, the creator NFT is minted, and LPLocker seeds a single-sided position. Leftover is burned.

The lock is a transient slot set in register(). Any swap in the same tx reverts. It clears with the tx, so there is no state to clean up and no sniping inside the launch block.

Full flow in the docs: https://t.co/AW7rCPqBG2

[Hookdaq @Hookdaq]

Your creator fee is an NFT. Here is what that means.

Launch a pool on Hookdaq and the factory mints you one ERC-721. Its token id is the pool id itself. One pool, one token.

That token is the only thing the hook checks at claim time. It calls ownerOf(tokenId) and pays whoever comes back. The address that launched the pool gates nothing.

Every buy and sell pays 50 bps on the quote side into that token's ledger. NVDA pool, NVDA ledger. Anti-Snipe tax lands in the same place, in the same asset. Nothing is converted, nothing is wrapped, and the balance sits as a claim on Uniswap's own PoolManager until you redeem it.

Claiming is one call: claimCreatorFees(tokenId, to). You hold the NFT, you pick the recipient. No minimum, no vesting, no admin approval.

And it is transferable, because a fee stream you can move is a fee stream you can price. Sell the NFT and you sell the stream, accrued fees included. Send it to a multisig and the team owns it instead of a founder wallet. The hook pays the current owner, whoever that is.

It is not governance. It cannot change the pool. Nothing can.

The creator fee on Hookdaq is not a promise to a wallet. It is an asset with an owner, and the chain pays the owner.