# Hooking agent skill

Read Kitchen coins, quote and trade them, launch one, add a floor bid and claim what a coin owes you, on Robinhood Chain. No account, no API key: every call is a chain read or a transaction your wallet signs. Paths are relative to https://hookingdotfun.com.

## Chain

- Robinhood Chain, chain id 4663
- Public RPC: https://rpc.mainnet.chain.robinhood.com
- Explorer: https://robinhoodchain.blockscout.com
- The Kitchen is deployed on Robinhood Chain. The addresses below are this site's own configuration.

## Addresses

From this site's runtime config. Trust only the ones on /security.

- KitchenFactory: `0x8A05203Ec5E16525Bb030B8Ef95e88DdAC087a99`
- KitchenHook: `0xf4B9F2BC2A8730B521114cDbD359db3b8AdA6aCC`
- KitchenRouter: `0xb2f828ca99e4E45137D55960158c93465225eeeD`
- LiquidityLocker: `0xA7322A82419f00Fee76f8f275ecB507572AdA3ac`
- FeeRouter: `0x4D358D773d16ceE17d6c00a806050D890CBD3F0D`
- KitchenRewards: `0x8850715A96E359dE836EAA7694396195C1922270`
- KitchenSellLens: `0x0779f612c5075FDD938F6ad0409e3f6f6f12D7D5`
- IngredientRegistry: `0x4c7928F89c5c4fD7699e18B63c7ff5EF40d7Af51`
- BlockRegistry: `0x4715a7b40a30E33CB7f7fCbd65d1b9d33a475679`
- KitchenRules: `0xb3f7bfb329858637f4D3bC0c44FE446592Eb61c3`
- KitchenRevenueRouter: `0xb65c5b4413A77C04abD7364220722225E6e9172A`
- KitchenRelayFactory: `0x127d5516496214f08cCa9999e5260646cA7F65AD`
- KitchenRevenueTokenFactory: `0xBf1506898DD6F3bA8126A2E34c5a4c3D6A4d666E`
- $HOOKING: `factory.hooking()` after genesis
- Uniswap v4 PoolManager: `0x8366a39CC670B4001A1121B8F6A443A643e40951`, StateView: `0xF3334192D15450CdD385c8B70e03f9A6bD9E673b`

Extensions and ingredients, with their state: /live.

## Rules

- Buying costs nothing on top of the swap, by default.
- Selling at a loss costs nothing.
- Selling at a profit pays a win tip of 10% of the realised profit, measured against your own cost basis (what your coins cost you, in the coin's quote): `tip = (proceeds - costOfTheCoinsSold) * 1000 / 10000`, never more than 10% of the proceeds. `coin.costOf(holder)` reads the basis; `TipCharged(coin, seller, profitQuote, tipQuote)` records each tip.
- A coin launched with blocks may add buy and sell charges, set by its creator and frozen at launch. They are shown on the coin's page; read them with `hook.blocks(poolId)` (the module, 0x0 for none) and `KitchenRules.configOf(coin)`.
- Right after launch the hook's anti-snipe window caps how much of the supply each buyer can take (a buy past it reverts `SnipeCap`).
- Every coin's liquidity is owned by the LiquidityLocker for good. Nobody can remove it.

## Coins and pools

- `factory.coinCount()`, `factory.coinAt(i)`, `factory.isKitchenCoin(coin)`, `factory.creatorOf(coin)`
- `hook.homePool(coin)` returns the PoolKey `{ currency0, currency1, fee, tickSpacing, hooks }`; `poolId = keccak256(abi.encode(PoolKey))`
- `hook.quoteOf(coin)`: 0x0 for an ETH pair, otherwise $HOOKING
- Price: the pool's tick from `StateView.getSlot0(poolId)` or `hook.meanTick(poolId, 0)`. One coin costs `1.0001^tick` of the quote when the coin is currency0, `1.0001^-tick` when it is currency1 (always on an ETH pair, ETH being 0x0). A $HOOKING-paired coin's ETH price goes through the $HOOKING pool.

## Quote and trade

```
router.buy(address coin, uint256 minCoinsOut, address recipient, uint256 deadline, bytes ticket)
  payable returns (uint256 coinsOut)        // msg.value is the ETH spent; ticket "0x"
router.sell(address coin, uint256 coinsIn, uint256 minEthOut, address recipient, uint256 deadline, bytes ticket)
  returns (uint256 ethOut)                  // approve the router on the coin first
sellLens.quoteSell(address coin, address seller, uint256 amount)
  returns (gross, take, costOfSold, tip, net, ethOut, quoterOut, taxBps)   // not view: eth_call it
```

Quote a buy by running `router.buy` as an `eth_call` with your value. Quote a sale with the sell lens: the V4Quoter's sell quote shows the hook's temporary hold, not the tip. A router sale pays ETH only; a $HOOKING-paired coin is routed coin to $HOOKING to ETH inside it.

## Launch

```
factory.launch(LaunchParams p) payable returns (address coin)
factory.launch(LaunchParams p, Blocks b) payable returns (address coin)   // b = { module: KitchenRules, data }
LaunchParams = { name, symbol, metadata: { image, description, x, telegram, website }, quoteIsEth, minCoinsOut, salt }
```

Send `factory.launchFee(quoteIsEth)` plus your first buy as `msg.value`. `factory.predictCoin(you, salt)` gives the coin's address before it exists. Blocks settings are encoded by packages/sdk (`encodeRules`, `encodeRulesWithExtensions`) and checked the way the contract checks them (`validateRules`, `validateExtensionList`).

## Floor bid

`feeRouter.creditLiquidity(address coin)`, payable: your ETH joins the coin's locked liquidity as a band under the price, for good. You get nothing back; every holder gets a deeper floor. ETH pairs only (a $HOOKING-paired coin reverts `NotEthQuoted`). `locker.bandRange(coin)` returns the band's ticks now. An amount too small for one unit of liquidity is burned whole.

## Claim

- A coin's creator: `feeRouter.creatorClaimable(creator)`, then `feeRouter.claimCreator()`
- King of the Pool winnings, across coins: `kotp.claim(winner)`
- Holder Pot share: `holderPot.claim(coin, wallet)`
- Swap Reward Mint share: `swapReward.claim(coin, wallet)`
- Tax + Conversion recipient: `taxConversion.claim(recipient)`
- Cashback and referrals: `rewards.claim(account, currency, cumulative, proof)`, the cumulative amount and proof from the published epoch

## Splits, relays and revenue tokens

A royalty or a tax can go to a split (up to 8 payees), a relay (up to 4 coins, bought and burned, bought for a wallet, or added to liquidity; anyone pours it for at most 1%) or a revenue token (its holders share what it is paid, released over 1 to 14 days). Each has its address before it exists: `predict` on its factory, or packages/sdk. Create it (anyone, idempotent), then: `split.distribute(0x0)`, `relay.pour()`, `token.sync()` and `token.claim()` or `claimFor(holder)`. `rules.claimRoyalty(recipient)` and `taxConversion.claim(recipient)` pay what is owed into it. Full terms: /llms-full.txt.

## Read API

https://api.hookingdotfun.com: `/kitchen/coins`, `/kitchen/market`, `/kitchen/coins/:coin/trades`, `/kitchen/coins/:coin/blocks`, `/kitchen/kings`, `/kitchen/ledger`, and the hook directory `/v4/hooks`, `/v4/hooks/:hook`. Bigints are "123n" strings. 503 with `why` while the indexer is behind: read the chain.

## Hooks

A Uniswap v4 hook's permissions are the lowest 14 bits of its address, and the PoolManager enforces them: `beforeSwapReturnDelta` (bit 3) and `afterSwapReturnDelta` (bit 2) let a hook take from swaps, `beforeRemoveLiquidity` (bit 9) lets it hold LPs in. /hooks lists every hook on the chain; /hooks/<address> reads one.

## MCP server

packages/mcp's hooking_* tools do all of the above for an agent, with no key: reads, and transactions returned unsigned (`to`, `data`, `value`) and dry-run as the sender: hooking_status, hooking_list_coins, hooking_get_coin, hooking_quote_buy, hooking_quote_sell, hooking_get_position, hooking_list_hooks, hooking_get_hook, hooking_get_recipient, hooking_tx_buy, hooking_tx_sell, hooking_tx_launch, hooking_tx_limit_place, hooking_tx_limit_cancel, hooking_tx_floor_bid, hooking_tx_create_split, hooking_tx_create_relay, hooking_tx_create_revenue_token, hooking_tx_pour, hooking_tx_split_payout, hooking_tx_revenue_token_claim, hooking_tx_collect. What each does: /llms-full.txt.

## Safety checks

1. Check the coin: `factory.isKitchenCoin(coin)`, and its address on its page.
2. Read its blocks before the first trade (`hook.blocks(poolId)`): a module can charge buys and sells.
3. Quote every trade and send a real minimum out, never 0.
4. Simulate before you sign; a refusal names its reason.
5. Every figure is a read at one block. Read it again before you rely on it.
6. Trust contract addresses only from https://hookingdotfun.com/security.

Full reference: /llms-full.txt.