# hookit.fun

> Launchpad on Ink (chain 57073) built on Uniswap v4 hooks. Every coin picks its own hook modules: anti-snipe, anti-MEV, max tx, dynamic fees, backed floor, auto-burn, deepen LPs, holder airdrop, creator payouts. An AI agent can launch a coin on its own, with its own key, and keep the creator fees.

## For agents

- MCP server: `npx -y hookit-mcp` with `HOOKIT_PRIVATE_KEY` in its env. The key signs locally and is never sent.
  Tools: `list_presets`, `list_modules`, `list_pairs`, `wallet_status`, `launch_token` (with `dryRun`), `claim_fees`, `send_eth` (with `dryRun`), `list_coins`, `coin_info`, `buy_token` and `sell_token` (with `dryRun`; ETH, USDG or the coin's pair, such as a tokenized stock), `redeem_floor`, `borrow_against_floor`, `repay_loan`, `agent_pass_challenge`, `claim_agent_pass`.
- Without MCP, two HTTP calls:
  - `GET https://www.hookit.fun/api/agents/catalog`: presets, modules with their settings and rules, pairs, payout targets.
  - `POST https://www.hookit.fun/api/agents/prepare-launch`: answers with one unsigned transaction (`tx.to`, `tx.data`, `tx.value`, `tx.gas`). Add `from` to simulate it from that wallet first.

Example body:

```json
{
  "name": "Roaring Kitty",
  "symbol": "KITTY",
  "image": "https://example.com/kitty.png",
  "pair": "eth",
  "preset": "community",
  "devBuyPct": 1,
  "payout": { "kind": "x", "handle": "@someone" },
  "from": "0xYourAgentWallet"
}
```

## Trading, Backed Floor and loans

- Coins: `GET https://www.hookit.fun/api/launches` (every coin: market cap, price, pair, hooks, gates), `GET /api/launches/<token>` (one coin), `GET /api/wallets/<address>` (a wallet's coins and their value).
- A coin trades in its pair (ETH, USDG, a tokenized stock, kBTC) through HookitSwapRouter `swapExactIn(poolKey, zeroForOne, amountIn, minAmountOut, 0)`; the factory's `tokenLaunchId(token)` and `poolKeyOfMarket(launchId, i)` give the pool keys (`launchMarketCount` markets on a multi-pair coin, else one). On v2 coins, USDG also buys and sells through the aggregator `RouteConfigC.aggregator()` (`buyExactInput` / `sellExactInput`, `quoteExactInput` to quote), bridged to the market's pair in the same transaction.
- Anything else (USDG for a coin priced in ETH, ETH for a coin priced in a stock, kBTC): swap it through Relay on Ink first, then trade. `POST https://www.hookit.fun/api/relay/quote` with `{ user, originChainId: 57073, destinationChainId: 57073, originCurrency, destinationCurrency, amount, slippageBps }` returns `{ requestId, amountOut, minimumAmount, calls[] }`; send `calls` in order from `user`, then `GET /api/relay/status?requestId=…`. hookit-mcp's `buy_token` and `sell_token` do this on their own when `payWith` or `receive` is not a pair the coin trades in.
- Multi-pair coins: a market pays sellers only with what its buyers paid in, so most stock markets of a new coin cannot take a sale yet, and the markets of one coin can drift apart in price. Quote every market (V4Quoter `quoteExactInputSingle`) before trading. hookit-mcp (0.2.1 and later) sells in the market that pays the most, buys in the cheapest one, and refuses to pay in a market priced far above the others.
- Backed Floor: the coin's hook names its vault (`floorVault()`); `redeemFloor(token, amount)` burns coins for their floor value (reserve / circulating supply, a price that never goes down).
- Loans (v2 coins launched with loans): FloorLoanPlugin `borrow(token, amount, duration, minNet)` locks coins for their floor value minus an upfront fee (7, 14, 30, 60 or 90 days: 1%, 1.75%, 3%, 5%, 7%); `repay(loanId, maxRepay)` before expiry pays their floor value then and returns them. Without repayment the coins are burned at expiry and the borrower keeps the loan.

## Agent Pass (AI-agents-only coins)

Some coins launch with Gated Buy in "AI agents only" mode: during a window after launch (up to 24 h), only wallets holding a Hookit Agent Pass can buy. The pass is non-transferable; a wallet gets it by passing a short agent check, then buys from the same wallet (the gate checks the transaction's signer, so smart wallets and relayers fail during the window).

- With hookit-mcp: `agent_pass_challenge` → answer the 5 tasks with `claim_agent_pass({ id, answers })` within 30 seconds → `buy_token({ token, amount })`.
- Over HTTP:
  1. `GET https://www.hookit.fun/api/agents/pass?wallet=0xYourAgentWallet` returns `{ id, wallet, pass, validator, tasks[5], issuedAt, expiresAt, message, instructions }`.
  2. Within 30 seconds, sign (EIP-191 `personal_sign`, the wallet's own key) the text `Hookit Agent Pass\nWallet: <checksummed wallet>\nChallenge: <id>\nAnswers: <a1> | <a2> | <a3> | <a4> | <a5>` with your answers exactly as you send them, then `POST https://www.hookit.fun/api/agents/pass` with `{ "id", "wallet", "answers": [...], "signature" }`.
  3. The answer carries `claim: { to, data }` (an EIP-712 voucher valid 10 minutes, only for that wallet): send it from the wallet. Already a holder: `{ alreadyHolder: true }`.
- One try per challenge. Limits: 20 challenges per hour per IP, 10 per wallet; 30 answers per hour per IP.
- During a Gated Buy window with a wallet cap, only exact-input buys go through (an exact-output buy reverts with `PluginBlocked(slot, 2)`); `buy_token` always buys exact-input.
- A pass proves the wallet passed the agent check, not that no human is behind it.

ERC-8004 agents on Ink (when the challenge's `validator` field is not null) can get Hookit's validation instead of a pass: the same check, with `"agentId": "<your identity id>"` added to the POST (with hookit-mcp: `claim_agent_pass({ id, answers, agentId })`), sent from the identity's operating wallet (`getAgentWallet(agentId)`). The answer carries `request` (the ERC-8004 ValidationRegistry `validationRequest`, sent by the identity's owner) then `validate` (sent by the operating wallet), or `validateLinkOnly` when the owner cannot send `request` (`alreadyValidated: true` when the wallet already counts: the steps then only publish the validation). `validate` also answers any request the owner already addressed to Hookit's validator for that identity: re-encode it with that request's hash. Hookit then publishes a 100/100 `hookit-agent` validation response anyone can read; the wallet counts as an agent on AI-agents-only coins. Selling the identity ends it.

## Presets

- `clean`: 1% fee, anti-snipe and anti-MEV at open, nothing else.
- `community`: 3% hook tax airdropped to holders every hour, 1% max tx.
- `deflationary`: 3% hook tax, half burns the coin, half deepens the pool.
- `floor`: 3% hook tax backs a redeemable floor price that never goes down (single pair).
- `builder`: 2% hook tax paid to the creator, vested over 90 days.
- `dynamic`: fee rises from 1% to 4% as trades eat the pool; the extra deepens liquidity.

Or pass `modules` (and `hookTaxPct`) to build a custom combination. The catalog lists every setting. Invalid combinations come back as a plain-words error before anything is signed.

## Money

- Swap fee: 1% base, plus the hook tax the launcher picks (up to 9%).
- The creator earns 60% of the base fee, paid in ETH or the pair token, collected from FeeEscrow with `claimAll` (the `claim_fees` tool).
- `payout` can send the creator fees to another wallet, or to an X, GitHub or TikTok account whose owner claims them. The launching wallet stays in control and can change the target later.
- Launch cost: a small launch fee in ETH plus gas. No minimum first buy.

## Dev buy

`devBuyPct` buys up to 2.5% of the supply in the launch transaction (lower when Max Tx is on). The anti-snipe tax does not apply to it. On ETH it is added to `tx.value`. On a token pair the answer carries an `approve` transaction to send first.

## Fund the agent from Kraken
Ink is Kraken's chain: Kraken withdraws ETH straight to Ink. Run the Kraken CLI MCP next to hookit-mcp to fund the wallet, then launch.
{"mcpServers":{"kraken":{"command":"kraken","args":["mcp","-s","market,account,funding"],"env":{"KRAKEN_API_KEY":"…","KRAKEN_API_SECRET":"…"}},"hookit":{"command":"npx","args":["-y","hookit-mcp"],"env":{"HOOKIT_PRIVATE_KEY":"0x…"}}}}
- Kraken trades on Kraken only; it cannot trade hookit coins. hookit-mcp does that on Ink.
- Kraken withdraws only to a saved address: whitelist the agent wallet on the Ink network first.
- When the wallet is short, wallet_status returns howToFund.
- To cash out: get the Kraken ETH deposit address on Ink from the Kraken MCP, then send_eth (hookit-mcp) sends the claimed fees there. Use only the address Kraken returns for the "ETH - Ink" deposit method, and send at least 0.001 ETH: Kraken marks smaller deposits as failed and the funds are lost. hookit-mcp 0.2.2 and later refuses to send less (belowKrakenMinimum: true only for an address that is not Kraken).

## Limits

- prepare-launch: 50 calls per hour per IP. Handle lookups (payout to @handle): 10 per hour; pass payout.accountId to skip them.
- Agent Pass: 20 challenges per hour per IP and 10 per wallet; 30 answers per hour per IP.
- Over the limit the API answers 429 with a retry-after header.

## Not available to agents yet

NFT Strategy launches. Use https://www.hookit.fun/launch for those.

## Warning

Give an agent a wallet funded for launches and nothing else. Most coins go to zero.