The full document
Hookline is a programmable market venue on Robinhood Chain.
Open a market. Write its economics as rules. Let them fire on-chain.
Every launchpad so far has you set the rules once, at launch, and live with them. A fee is a number. A fee recipient is an address. Liquidity is locked or it is not. Nothing moves after the first block, whatever happens to the market or to the people behind it.
Hookline starts from a different premise: a market's rules should answer to what the market does and to what can be proven about it. A creator proves who they are, and the routing changes. Liquidity crosses a line, and the fee drops. A milestone is attested, and rewards switch on. An agent proves a condition, and a rule written at launch fires. All of it inside the swap, enforced by a Uniswap v4 hook, with hard limits no rule can cross.
This document covers what a market is here, how its program runs, who gets paid, what can and cannot change, and what the $HOOKLINE token does. It carries no dates. Things ship in an order, and each step is announced when it is done.
Why the rules should move
A launch is one transaction. A market is a whole life. The moments below get handled off-chain today, by a multisig vote, by someone calling a contract by hand, or not at all. Hookline moves them into the hook.
At launch
Nobody is verified and nobody has depth. The right move is to protect the pool and the people who turn up first: a full fee, the creator's share held in escrow, the launcher's share held back.
The creator shows up
Once they prove the handle, they should be paid straight to their wallet, not through an escrow or a promise. The routing switches in one rule.
The pool gets deep
A fee that was fair at ten ETH of liquidity is a tax at a thousand. A State rule lowers it when the chain says the depth is there.
Something real lands
A product ships, a number is hit, a vote passes. The economics should be allowed to reward it, with rewards and incentives that were funded and capped at launch.
Programmable tokens put the rules in the asset. Hookline puts them in the venue.
How a market is born
A market on Hookline is three things created in one transaction:
- A token. Fixed supply, minted once, no mint function, no owner. One billion units by default.
- A pool. A Uniswap v4 pool between the token and a quote asset (ETH by default, see Quote in a stock), opened at a published starting price, with the entire supply placed as one single-sided position and locked in a contract that has no withdraw function.
- A program. The ordered list of rules that steer the market's economics, picked from a template and filled in by the launcher. See Programs and rules.
The launcher pays a small creation fee in ETH and signs once. There is no presale, no allocation to the launcher, and no way to seed the pool with less than the full supply. From the first block the market trades, the liquidity is locked, and the program is live.
What the launcher decides
- The template, and the blanks it exposes: thresholds, recipients, windows.
- The quote asset, from the allowed list.
- The token's name and symbol.
- Who the market is about, if the template has a creator: a handle on a supported platform, or a wallet.
What the launcher cannot decide
- A fee above the engine's cap.
- A recipient outside the market's declared set.
- Any path that removes liquidity.
- Any path that reaches an escrow without its claim.
Those are properties of the engine, not of the template. They are listed under What cannot change.
Programs and rules
A program is an ordered list of rules. A rule has this shape:
when <condition> then <action> [once | repeatable] [after <rule>]On every swap the hook reads the market's current economics: the fee rate, the routing table, the liquidity mode, the rewards switch. Rules change those values. Nothing else can.
Conditions
| Condition | What proves it | Example |
|---|---|---|
Verified(event) | A signature from an allow-listed verifier, bound to this market, with a nonce and a deadline | the creator owns the handle; the team hit a public milestone |
State(metric op value) | Read from the chain at evaluation time | liquidity ≥ 50 ETH; cumulative volume ≥ 1,000 ETH; 30 days since launch; holders ≥ 500 |
Agent(key) | A call from an allow-listed agent address, and the rule's own State or Verified check still passing | an agent fires "lower the fee" in the block liquidity crosses the line |
Vote(threshold) | An on-chain signal from holders of the market token (later release) | the community turns rewards on |
Agents execute. They do not decide. A rule whose only condition is an agent is rejected when the program is created. An agent can make a true rule fire sooner. It cannot make a false rule fire at all.
Actions
| Action | Limit the engine enforces |
|---|---|
SetFee(bps) | 0 to 300. Never above 3%. |
SetRouting(recipients, shares) | Shares sum to the fee; recipients only from the market's declared set |
RouteToEscrow / RouteToCreator | The claim switch. The escrow is reachable only through its claim. |
ActivateRewards / DeactivateRewards | Turns the holders' share on or off. What has accrued is never clawed back. |
SetLiquidityMode(mode) | locked or locked_plus_buyback. Removal is not a mode. |
ReleaseIncentive(amount, to) | From the market's pre-funded incentive vault only, capped per rule at creation |
Evaluation
Anyone can call evaluate(market, rule, proof). If the condition holds, the action lands in that transaction and a RuleFired event goes out with the rule, the proof and the new economics. If it does not hold, the call reverts and nothing moves. The protocol runs an agent that evaluates every market's State rules in each block they could plausibly fire; anyone else can run one too.
Reading a program
Every market's program is public and readable in the interface: each rule, its condition, whether it has fired, when, and what it changed. A market with a program nobody can read is not a market on Hookline.
Templates
A template is a saved program with blanks. Launching from a template fills the blanks and installs the rules in one transaction. The first templates:
Person
A market about a person with a handle. Fee 3%. Routing as in Who gets paid.
when Verified(ownership) then RouteToCreator, oncewhen State(days_since_launch ≥ 90) and not claimed then SweepEscrowToHolders, once
Creator
A market launched by its own creator, verified at launch. L and V are thresholds the launcher fills in.
when State(liquidity ≥ L) then SetFee(150), oncewhen State(volume ≥ V) then ActivateRewards, once
Milestone
A team market with rewards off until something real happens.
when Verified(milestone) then ActivateRewards, oncewhen Verified(milestone) then ReleaseIncentive(A, holders), once, after the rule above
Stock-quoted
Any of the above with a Robinhood Stock Token as the quote asset. See Quote in a stock.
Templates are added by the protocol and, later, by $HOOKLINE governance. Every template is published with its rules in full before any market can use it.
Verification
Verified(event) rules depend on someone attesting that something happened. Hookline keeps that role small, auditable and replaceable.
Verifiers
A verifier is a signing key on the engine's allow-list. It signs a typed message: the market, the event, the subject, a nonce and a deadline. The hook checks the signature, the nonce and the deadline, then evaluates the rule. A signature for one market cannot be replayed on another.
At launch the protocol runs the first verifier. The allow-list is public, additions and removals are announced before they take effect, and a market can require signatures from more than one verifier.
Events
| Event | How it is established |
|---|---|
ownership(platform, handle) | A code placed in the handle's public profile, or an OAuth login, checked by the verifier |
ownership(wallet) | A signed message from the wallet |
milestone(id) | A public, dated, verifiable statement defined in the program at launch: a URL, a contract address, a number on-chain |
A Verified rule names the event it needs at creation. The verifier cannot invent events a program never asked for.
Agents
An agent is any address allowed to call evaluate on rules marked for agents. The agent pays the gas. The rule still has to be true: an agent cannot sign for a verifier, cannot read state that is not there, and cannot fire a once rule twice.
What a verifier can and cannot do
It can delay a true claim by refusing to sign. It cannot move funds, change economics directly, or sign for an event the program did not define. If a verifier goes dark, the allow-list is updated and the claim proceeds with another one.
Who gets paid
Every trade pays a fee on the quote side, taken inside the swap by the hook and split in the same transaction. The fee rate and the routing are part of the market's economics and can change by rule, within the limits below.
The declared set
A market names its recipients at launch. The engine knows six kinds:
| Recipient | Who |
|---|---|
| Creator | The person or team the market is about. Paid direct once verified; parked in escrow until then. |
| Launcher | The wallet that opened the market. |
| Holders | Everyone holding the market token, weighted by balance and time, through the holders pool. |
| Protocol | Hookline. Funds buybacks and operations; pays referral links out of its own share. |
| Referral | The wallet whose link brought the trade, paid from the protocol share. |
| Escrow | The creator's share while unverified. |
A program can shift shares between these. It cannot invent a seventh.
The default: the Person template
| Recipient | Before the creator verifies | After |
|---|---|---|
| Creator | 2.00% (to escrow) | 1.50% (direct) |
| Launcher | 0 | 0.50% |
| Holders | 0.50% | 0.50% |
| Protocol | 0.50% (of which up to 0.25% to a referral link) | same |
The switch from the left column to the right is a single rule: when Verified(ownership) then RouteToCreator. Until it fires, the launcher's share goes to the creator, so opening a market about someone is never a way to tax them.
Escrow
The creator's share accrues in a contract keyed to the creator's identity, never to a wallet. It moves in exactly two cases: the creator proves the identity and claims it, or the claim window closes and it is paid to the holders pool. It is never burned and never reachable by the launcher, by the protocol, or by any rule.
Referral links
Every wallet has a link for every market. A trade that arrives through a link pays up to a quarter point of that trade to the link's owner, out of the protocol share. The other recipients are untouched.
Liquidity
At launch the entire token supply goes into the market's Uniswap v4 pool as one single-sided position, from the starting price upward. The position is held by a contract with no function that removes liquidity. Not paused, not time-locked, not governed. Absent.
Fees earned by that position accrue to the position and stay in the pool.
Modes
locked: the default. Nothing moves.locked_plus_buyback: a share of the protocol's fee from this market buys the market token on the open market and adds it to the locked position.
Both modes keep the position locked. There is no mode in which liquidity leaves.
Why single-sided
Because it means the launcher puts in nothing but the creation fee, holds nothing at launch, and cannot have pre-bought. The first buyer pays the starting price. There is nothing to dump.
What cannot change
Three things no program can do. They are not in any template, cannot be added by any program, and are not parameters. They are properties of the engine.
- Pull the liquidity. The lock contract has no such function. Not paused, not time-locked, not governed: absent.
- Touch an escrow without its claim. The escrow moves on a verified claim, or to the holders once the window closes. Nothing else reaches it.
- Push the fee past 3%. The hook refuses it at the engine level, before any rule gets a say.
Changing any of these is not a parameter change or a governance vote. It is a different engine, published and reviewed as one, and existing markets stay on the one they launched on.
Quote in a stock
Robinhood Chain carries Robinhood Stock Tokens: ERC-20 tokens tracking listed equities. A market on Hookline can use one of them as its quote asset instead of ETH.
That changes what a market is. A market about a company's founder, quoted in the company's stock token, pays its creator, its holders and its launcher in that stock on every trade. Backing the person and holding the business become the same position.
Rules
- The quote asset must be on the engine's allowed list. The list starts with ETH and adds Stock Tokens one at a time, each with a published price feed and a staleness limit.
- A market's quote asset is fixed at launch. A program cannot change it.
- Stock Tokens carry their issuer's own transfer restrictions. The interface shows them before launch and before every trade. The engine does not override them.
- Markets quoted in a Stock Token start at a price expressed in that token, from the feed at launch.
This is the part of Hookline that exists only on Robinhood Chain. It ships after ETH-quoted markets.
The numbers
| Parameter | Start | Range |
|---|---|---|
| Fee on every trade | 3.00% | 0 to 3.00%, per market by rule |
| Creator, unverified / verified (Person) | 2.00% / 1.50% | within the fee |
| Launcher, after verification (Person) | 0.50% | 0 to 1.00% |
| Holders | 0.50% | 0 to 1.00% |
| Protocol | 0.50% | 0.25% to 1.00% |
| Referral, from the protocol share | up to 0.25% | 0 to 0.50% |
| Creation fee | 0.005 ETH | 0 to 0.01 ETH |
| Token supply | 1,000,000,000 | fixed |
| Starting valuation | $10,000 equivalent | $5,000 to $50,000 |
| Claim window | 90 days | 30 to 365 days |
| Buyback share of protocol net | 50% | 25% to 75% |
| Price feed staleness | 1 hour | 15 minutes to 24 hours |
Anything outside a range is not a parameter change. It is a new version, published and reviewed as one.
Under the hood
| Contract | Role |
|---|---|
MarketFactory | Creates token, pool, locked position and program in one call. Pausable for new launches only. |
MarketToken | Fixed-supply ERC-20. Notifies the holders pool on transfer. |
HooklineHook | The Uniswap v4 hook. Takes the fee inside the swap, routes it, enforces the liquidity guards, holds each market's economics, exposes evaluate. One instance serves every market. |
ProgramRegistry | Templates, rule encoding and validation, per-market programs. Rejects anything outside the engine's limits at creation. |
Verifier | Typed-signature attestations, the verifier allow-list, nonces and deadlines. |
CreatorEscrow | Holds the creator's share by identity until claimed or swept. |
HoldersPool | Reward-per-token distribution to holders of a market. |
IncentiveVault | Pre-funded per-market vault for ReleaseIncentive. |
LiquidityLock | Holds the position. No removal function. |
MarketRouter | Exact-input swaps with the referral payload. Holds nothing. |
QuoteRegistry | Allowed quote assets, price feeds, staleness and sequencer checks. |
All contracts are verified on the explorer at deployment. Addresses go on the Addresses page as each one ships.
Trust
- Sells, claims, withdrawals, sweeps and
evaluatecannot be paused. - New launches can be paused by the multisig. Existing markets are unaffected.
- Parameter changes apply only within the bounds in The numbers, are announced before they take effect, and never apply to a past trade.
- No contract holds a key to any market's liquidity or escrow.
$HOOKLINE
The protocol's token. You do not need it to launch, trade, hold, verify or evaluate anything. No rule in any template asks for it.
| Supply | 1,000,000,000, fixed |
| Mint function | None |
| Chain | Robinhood Chain |
| Address | 0x175aeb072426cd37f1b7c50ee41714ef1d46473b |
| Trade | pons.trade |
Buybacks
A published share of the protocol's net fee income buys $HOOKLINE on the open market and burns it. A contract does it; anyone can call it. It is how the protocol spends part of its revenue, not a floor under anything.
Governance
Holders decide which templates get added, which quote assets are allowed, which verifiers are on the list, and parameter changes inside published bounds.
Later, weight
A future release lets $HOOKLINE be staked to raise a wallet's weight in the holders pools of the markets it holds, up to a published cap.
Straight talk
Read this before anything else.
Markets can go to zero.
A program changes the economics. It does not create demand. Most markets anywhere end at zero, and nothing here changes that.
A rule is only as good as its condition.
A Verified rule trusts a verifier's signature. A State rule trusts the chain. If you would not trust us to sign, do not open a market that depends on our signature.
Verification is not endorsement.
A creator proving a handle means the money reaches them. It does not mean they asked for the market, like it, or will ever acknowledge it.
$HOOKLINE is a position in a plan.
The token exists before the contracts do. It funds the build in the open. It carries no claim on revenue until buybacks are live, no vote until governance is live, and no weight until staking is live. Each of those is announced when it is done, not before.
Nobody from this project will message you first.
No DMs, no seed phrase requests, no claim links. The only addresses that count are on the Addresses page.
Words
- Market: a token, its pool and its program, created together.
- Program: the ordered list of rules installed on a market.
- Rule:
when condition then action. - Economics: the values the hook reads on every swap: fee, routing, liquidity mode, rewards switch.
- Template: a saved program with blanks.
- Verifier: an allow-listed key that attests events.
- Agent: an address allowed to call
evaluateon rules marked for agents. - Creator: the person or team a market is about.
- Launcher: the wallet that created the market.
- Holders pool: where the holders' share of fees accrues, by balance and time.
- Escrow: where the creator's share waits until verified.
- Quote asset: what a market is priced and paid in: ETH or an allowed Stock Token.
Addresses
This is the only list that counts. Anything not on it is not ours.
| What | Where |
|---|---|
| Site | tryhookline.app |
| X | @hooklineHQ |
| $HOOKLINE | 0x175aeb072426cd37f1b7c50ee41714ef1d46473b Trade on pons |
| Contracts | Published here as each one is deployed and verified |