The programmable market layer / Robinhood Chain

Markets thatreact.

Launch a market. Program its economics. Let it evolve on-chain. The rules are written at launch. The change happens later, automatically, when the condition is met and proven. The launcher does not hold a key to it. Neither do we.

Launch a marketProgram its economicsLet it evolve on-chain
Fee never above 3%The hook refuses it at the engine level.
Liquidity cannot leaveThe locking contract has no withdraw function.
Escrow moves by claim onlyNever reachable by the launcher, the protocol, or any rule.
Every program is publicEach rule, its condition, whether it fired, and what it changed.
See it react

Pick a template. Make something happen.

A template is a saved program with blanks. These are the first three, with their rules exactly as written in the docs. Press an event and watch the market's economics change.

The program

Something happens

Economics now

Why rules should change

A launch is a bet made in one transaction. A market has a lifecycle.

Every launchpad so far asks you to set the rules once and live with them. Today the moments below are handled off-chain, by multisig votes, by manual contract calls, or not at all. Dynamic Hooks moves them into the hook.

At launch

Nobody is verified and nobody has liquidity. The right thing to do is protect the pool and the people who show up early.

The creator proves who they are

They should be paid directly, not through an escrow or a promise.

The market gets deep

The fee that made sense at ten ETH of liquidity is a tax at a thousand.

The community hits something real

A product shipped, a number reached, a vote passed. The economics should be allowed to reward it.

Programmable tokens put rules in the asset. Programmable markets put rules in the venue.

How a market is born

Three things, one transaction.

The launcher pays a small creation fee in ETH and signs once. No presale, no allocation to the launcher, and no way to seed the pool with less than the full supply.

A token

Fixed supply, minted once, no mint function, no owner. The default is 1,000,000,000 units.

A pool

A Uniswap v4 pool against ETH, with the whole supply placed as a single-sided position and locked in a contract that has no withdraw function.

A program

The list of rules that govern the market's economics, chosen from a template and filled in by the launcher.

Programs and rules

A program is an ordered list of rules.

The hook reads the market's economics on every swap: the fee rate, the routing table, the liquidity mode, the rewards switch. Rules change those values. Nothing else can.

when <condition>  then <action>   [once | repeatable]   [after <rule>]

What can fire a rule

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.

Vote(threshold)

An on-chain signal from holders of the market token. A later release.

Agents execute; they do not decide. An agent can make a true rule fire sooner. It cannot make a false rule fire at all.

What a rule may change

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 / RouteToCreatorThe claim switch. The escrow is reachable only by its claim.
ActivateRewards / DeactivateRewardsTurns the holders' share on or off. Accrued balances are 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.
Anyone can call evaluate. If the condition holds, the action is applied in that transaction and a RuleFired event is emitted. If it does not hold, the call reverts and nothing changes.
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.

01

Remove liquidity

The locking contract has no such function. Not paused, not time-locked, not governed: absent.

02

Reach an escrow without its claim

The escrow moves on a verified claim, or to the holders after the window. Nothing else.

03

Set a fee above 3%

The hook refuses it at the engine level.

The token
$DHOOKS

The protocol's token. You do not need it to launch, trade, hold, verify or evaluate anything. No rule in any template requires it.

Supply1,000,000,000, fixed
Mint functionNone
ChainRobinhood Chain

Buybacks

A published share of the protocol's net fee income buys $DHOOKS 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 are added, which quote assets are allowed, which verifiers are on the list, and parameter changes within published bounds.

Later, weight

A future release lets $DHOOKS be staked to increase a wallet's weight in the holders pools of the markets it holds, up to a published cap.

$DHOOKS comes first. The token comes before the protocol so the build can be funded in the open. Until markets open, holding it is holding a position in the plan, and plans can fail.
What comes next

An order, not a calendar.

Each step starts when the one before it has been checked. No step has a date, and none will be given one until it is done.

  1. The document and the token

    The docs, this site, and $DHOOKS on Robinhood Chain.

  2. The build

    The contracts tested against a copy of Robinhood Chain and on its public testnet. Review of the hook, the program registry, the escrow and the lock, with findings published. Deployment behind the launch pause, exercised with the team's own money on real markets.

  3. Markets open

    ETH-quoted markets from the Person, Creator and Milestone templates. Rules, holders pools, referral links and the first verifier from the first market.

  4. Quote in a stock

    The allowed list opens with the first Robinhood Stock Tokens.

  5. Votes and weight

    Vote as a condition. $DHOOKS staking for holders-pool weight, written up on its own and reviewed before it ships.

Straight talk

Read this before anything else.

Markets can go to zero.

The program changes economics; it does not create demand. Most markets anywhere end at zero.

Rules are only as good as their conditions.

A Verified rule trusts a verifier's signature. A State rule trusts the chain. If you would not trust us to sign, do not launch a market that depends on our signature.

Verification is not endorsement.

A creator proving a handle means the money goes to them. It does not mean they asked for the market, like it, or will ever acknowledge it.

Questions

Short answers.

Who can fire a rule?

Anyone. Calling evaluate on a rule whose condition holds applies the action in that transaction. If the condition does not hold, the call reverts and nothing changes. The protocol runs an agent that evaluates State rules; anyone else can run one too.

Can the launcher change the rules after launch?

No. The rule is written at launch. The change happens later, automatically, when the condition is met and proven. The launcher does not hold a key to it, and neither does the protocol.

What can a verifier do, and not 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.

What happens to the creator's share if they never show up?

It accrues in an escrow keyed to the creator's identity. It moves in exactly two cases: the creator proves the identity and claims it, or the claim window passes and it is paid to the holders pool. It is never burned.

Does the launcher get tokens at launch?

No. The entire supply is placed as one single-sided position in the pool. 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.

Do I need $DHOOKS to use the protocol?

No. You do not need it to launch, trade, hold, verify or evaluate anything.

The full document

Rules belong in the venue.

The docs explain what a market is here, how its program works, who gets paid, and what can and cannot change.