# cook4.fun

> Launch and trade memecoins on Robinhood Chain. Every coin goes live on Uniswap V4
> the instant it launches. This file documents the on-chain interface so agents can
> read, buy, sell, and launch programmatically. You always sign with your OWN wallet —
> cook4.fun is non-custodial and never holds keys or moves funds on your behalf.

## Chain

- Robinhood Chain, chainId **4663**
- RPC: `https://rpc.mainnet.chain.robinhood.com`
- Explorer: `https://robinhoodchain.blockscout.com`

## Contracts

- **Launchpad** (current, V4-native): `0xcdC8D6C3DdA334730262Fd7D7f0Ee5E86bA4Ff47`
- **Uniswap V4 PoolManager** (the singleton every coin trades on): `0x8366a39CC670B4001A1121B8F6A443A643e40951`
- **Pool hook** (guards pool creation only, never runs on swaps): `0x4245822772d196A046Ac69Ed307551b3Bfb52000`
- **Token implementation** (every coin is an EIP-1167 clone of this): `0x4CcfcAad121f7082cee86ee76D76f24F7Cd35720`

The full launchpad ABI is documented below. Older coins launched on the previous
V3-native launchpads (`0xc12F4cc3d6a1a91B03827632C4D744454350A352` and
`0xFd52AD20092984c1405181AB0327a7D98Bd4513a`) still trade on those contracts, but
all new launches and site activity are on the V4 launchpad above.

## Read (view functions on the launchpad)

- `getTokens(uint256 offset, uint256 limit) -> (TokenInfo[] tokens, uint256 total)`
- `getToken(address token) -> TokenInfo` — fields: name, symbol, description, imageUrl,
  twitter, telegram, website, createdAt, creator, `distribute` (fee-sharing on/off),
  `poolId` (bytes32, the Uniswap V4 pool id), `tickLower`, `tickUpper`, `liquidity`.
  Reverts with "reg" if the token is not on this launchpad.
- `getPrice(address token) -> uint256` — ETH (wei) per whole token
- `getMCAP(address token) -> uint256` — fully-diluted market cap in ETH (wei)
- `mcapsOf(address[] tokens) -> uint256[]` — batch market caps
- `getSplits(address token) -> Split[]` — how the creator fee is split (empty = creator keeps all)

Total supply is fixed at 1,000,000,000e18 for every coin.

## Buy (payable)

```
buy(address token, uint256 minOut) payable
```
- Send ETH as `msg.value`. Tokens go to `msg.sender`.
- `minOut` = minimum tokens to accept (slippage guard). Estimate from `getPrice`,
  or pass `0` to disable (not recommended).

## Sell (two steps)

```
1) approve(launchpad, amount)         // on the ERC20 token — spender is the LAUNCHPAD
2) sell(address token, uint256 amount, uint256 minEth)
```
- Returns ETH to `msg.sender`. `minEth` = slippage guard.
- Only ever approve the launchpad address above — nothing else.

## Launch a coin (payable)

```
struct Split { address to; uint16 bps; }   // bps = share of YOUR creator fee, out of 10000

createToken(
  string name, string symbol, string description,
  string image, string twitter, string telegram, string website,
  bool distribute, uint256 firstBuy, string metadataURI,
  bytes32 salt, Split[] splits
) payable
```
- `msg.value` = 0.001 ETH service fee + `firstBuy` (optional amount to buy at launch; 0 for none).
- `distribute = true` shares the pool's 1% LP fees pro-rata to holders. When true, `splits` is ignored.
- `metadataURI` = optional URL to a JSON (image + socials) exposed via the token's
  `contractURI()` (ERC-7572). Pass "" to skip.
- `salt` = any bytes32. The token is deployed with CREATE2, so its address is
  determined off-chain before you send: `address = CREATE2(launchpad,
  keccak256(abi.encode(msg.sender, salt)), cloneInitCodeHash)`, where
  `cloneInitCodeHash = keccak256(0x3d602d80600a3d3981f3363d3d373d3d3d363d73 ++
  <tokenImplementation> ++ 0x5af43d82803e903d91602b57fd5bf3)`. Pass any value if
  you don't care about the address; grind salts if you want a vanity suffix
  (cook4.fun coins all end in `c00c`). The sender is mixed in, so a salt only ever
  resolves to an address for you — nobody can front-run it. Field limits: name ≤64,
  symbol ≤32, description ≤512, each URL/URI ≤256 chars.
- `splits` = optional split of your 75% creator fee among up to 5 wallets, each in
  bps of that share (must sum ≤ 10000). Fixed at launch and never editable. Empty = you keep it all.
- The full 1B supply is deployed as a single-sided Uniswap V4 position (~1.5 ETH starting FDV).

## Creator fees (non-distribute coins)

Your 75% cut is pushed to your wallet on every trade that goes through the site, or
whenever anyone calls `pokeFees(address token)` (permissionless). If your coin trades
mostly on Uniswap directly, call `pokeFees` to sweep what has accrued.

## Token metadata (on the token contract, ERC-7572)

```
contractURI() -> string   // URL to a JSON: { image, external_url, properties:{ files, category, website } }
metadataURI() -> string   // same
creator() -> address
launchpad() -> address
```

## Trade directly on Uniswap V4 (optional)

Every coin's pool lives in the V4 PoolManager singleton, not at a per-pool address.
Native ETH is `address(0)`, which sorts first, so ETH is always currency0 and the
token is currency1. The PoolKey is:

```
PoolKey {
  currency0: address(0),        // native ETH
  currency1: <token>,
  fee:       10000,             // 1%
  tickSpacing: 200,
  hooks:     0x4245822772d196A046Ac69Ed307551b3Bfb52000
}
```
The hook only guards pool creation (`beforeInitialize`); it does not run on swaps,
so you can swap against the pool normally. The coin's `poolId` from `getToken` is
`keccak256(abi.encode(PoolKey))`, and the singleton emits
`Swap(bytes32 indexed id, address indexed sender, int128 amount0, int128 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint24 fee)`
per trade (amount0 = ETH leg, amount1 = token leg; a negative amount0 is a buy).

## Notes

- Non-custodial: you sign every transaction with your own wallet. There is no
  endpoint that holds keys or trades on your behalf.
- The token implementation is verified on Blockscout, so every coin (a clone of it)
  shows verified source there; the launchpad interface is documented above.