---
name: hookr-elysium
description: Read Hookr pools on Uniswap v4 on Elysium, quote and swap, open pools and claim income. MCP at https://hookr.fun/api/mcp?network=elysium, no key.
---

# Hookr agent skill: Elysium

No account, no API key; your wallet signs every call. Paths are relative to https://hookr.fun.

## Start here

MCP: `https://hookr.fun/api/mcp?network=elysium`, POST only, no key, /docs/mcp. It builds unsigned calls simulated from your wallet and never sends.

- Read pools: `hookr_pools`, `hookr_pool`, `hookr_blocks`, `hookr_release`
- Trade: `hookr_quote`, `hookr_check_trade`, `hookr_build_swap`
- Launch: `hookr_build_launch` opens a new token's pool on HYPE in one call, arb recapture on unless `arbRecapture` is false.
- Claim: `hookr_claims`, `hookr_build_claim`
- Paid job: relay signed swaps, where a signed buy needs a pool priced in a token, not HYPE: /docs/integrations/agent-jobs

At 15% impact, unread impact or a look-alike token no answer is `ok`; `hookr_build_swap`'s `accept` builds it anyway.

## Chain

- Chain: Elysium, chain id 99901
- HOOKR is not on Elysium: a token there with that symbol is not HOOKR
- Public RPC: https://rpc-elysium-mainnet.t.conduit.xyz
- Explorer: https://elysium.kinetiq.xyz/explorer
- Quote: HYPE, the native (0x0)

## Addresses

To read or claim, use the core a pool's `PoolConfig` names.

- HookrRules, the core: `0x342bAA22e202954593b04B7eD1663621E0565d46`. New pools on HookrRoot bind it.
- HookrLauncher (new tokens): `0x70a66ADF39B5c9FfEE4A9F081C182edfbb7DBD0C`. Use it for a new token.
- HookrFamilyLock (new tokens): `0x5248AF9139DaDEf0C5296342b7BE441deDf0adC2`. For the new-token launcher's families.
- HookrRoot: `0x89c9FB50d1f03192230FFB1c279BB6E7d3Fe6aCc`
- HookrRouter: `0xC2Bc9a3fe6c4Ce8C2F7EB4655b0869b01D8c93C9`
- HookrQuoter: `0x445D7891381Aa7F91F5048EdBC6a611ccBDe7865`
- HookrLauncher (existing tokens): `0x1cf2748A6670572425eAbf9Ab9e5BC4eb2eB8Ef4`. Use it for a token that already trades.
- HookrRegistry: `0x463c82beA1a52F4Cc05ca0741a24F0AD24bA4602`
- HookrTreasury: `0x2242F7FC75606500503075f29ea8cDA684EfB4a9`
- PoolManager: `0xE2e105d3F7209A9DA11f83cCf3E7398a753823F1`
- PositionManager: `0x1d1C51b9d07fD27d36412A2b66CC23D19Eb3E518`
- Permit2: `0x000000000022D473030F116dDEE9F6B43aC78BA3`

Universal Router: `0xA13f7611115752DEB2B13813BDDE16A5073e4b45`.

## Pool key and pool id

```
PoolKey = {
  currency0: lower(subject, quote),  // numeric compare; 0x0 (HYPE) sorts first
  currency1: higher(subject, quote),
  fee: 0x800000,  // dynamic-fee flag, not a real fee
  tickSpacing: <the pool's>,
  hooks: HookrRoot,
}
poolId = keccak256(abi.encode(PoolKey))  // bytes32
```

Or read `launcher.memberKey(subject, quote, tickSpacing, root) view returns (PoolKey key, bool available)`.

## Read a pool's Hook Blocks

```
root.poolConfig(poolId) view returns (PoolConfig)
core.config(poolId) view returns (RulesConfig)  // core = the PoolConfig's rules address
```

`PoolConfig` names the core, one advisory (0x0 = none), `liquidityOwner` and `baseLpFeePips`.
Both structs freeze at launch. `RulesConfig` fields, in order (pips = 1e-6, bps = 1e-4):
guardEndBlock, maxFeePips, snipeTaxPips, snipeFloorPips, snipeDecaySeconds, dynamicFeeSens, burnBps, lpBps, potBps, royaltyBps, protocolShareBps, potEveryNBuys, maxBuyQuoteAmount, potMinBuyQuote, royaltyTo, integrator. On the listed core:

- `guardEndBlock` uint40: Anti-Snipe end on Elysium's clock (block timestamp / 12), 0 = off
- `potBps` uint16: King of the Pool's share of what is left of arb recapture profit (bps), 0 = off
- `protocolShareBps` uint16: Hookr's share of block charges (bps)
- `potEveryNBuys` uint32: packed block settings; launch opt-out bit 18 is cleared before storage
- `maxBuyQuoteAmount` uint128: Anti-Snipe max buy per 12-second step, 0 = off
- `potMinBuyQuote` uint128: packed block settings, not a raw Wallet Cap amount
- `integrator` address: listed integrator, 0x0 = none

## Quote and swap

```
router.swap(Swap s, address engagement, uint256[] campaigns) payable
  returns (uint256 amountIn, uint256 amountOut)  // engagement 0x0, campaigns [] for none
Swap = { key, zeroForOne, amountSpecified, amountBound, sqrtPriceLimitX96, recipient, deadline }
quoter.quote(Swap s, address payer) returns (ExecutionReceipt)  // not view: eth_call
```

HookrRouter pays `recipient` and refunds unused HYPE. `amountSpecified` is negative for exact input;
`amountBound` is the minimum out (or maximum in), never zero. `sqrtPriceLimitX96`: 4295128740 if
`zeroForOne`, else 1461446703485210103287273052203988822378723970341, to fill in full. Native input goes as `msg.value`;
for an ERC-20, approve the router itself, not Permit2.

Universal Router: `V4_SWAP`, same `PoolKey`, empty `hookData`, Permit2; quote with `quoter.quoteExactInputSingle`
or `quoteExactOutputSingle`. Every Hook Block applies either way.

With arb recapture on, a swap carries the lane's `gasFloor` (`root.laneOf(poolId)`)
plus its own gas. `eth_estimateGas` includes the floor: send the estimate
plus a sixth. A fixed limit: at least 8.8 million.

## Provide liquidity

Uniswap v4 `PositionManager`: `Actions.MINT_POSITION(poolKey, tickLower, tickUpper, liquidity, amount0Max,
amount1Max, owner, hookData=0x)` then `SETTLE_PAIR`; an ERC-20 leg goes through Permit2. While a pool's
Anti-Snipe window is open only its `liquidityOwner` can add. `guardEndBlock` counts 12-second
steps: compare it with the latest block's timestamp divided by 12, never `eth_blockNumber`.

## Open pools

```
launcher.launch(Token token, address root, Member[] members, uint256 deadline) payable
  returns (bytes32 familyId, address subject)
Token = { existing, name, symbol, supply, salt }
Member = { quote, tickSpacing, sqrtPriceX96, tickLower, tickUpper, liquidity, amount0Max,
  amount1Max, config: PoolConfig, rules: RulesConfig, recapture: RecaptureConfig }
```

One pool per member. New token: `existing` 0x0, nonzero `supply`; `launcher.predictToken(you, token)`
gives its address. Existing token: `existing` set, the rest empty. `msg.value`: the native budgets plus
`launcher.launchFee()`, exactly; unused budget is refunded. Recapture on: `traderBps` 0, `lpBps` 10000, `releaseBlocks` 36000. To opt out, set bit 18 in `rules.potEveryNBuys` and zero `recapture`; zero `recapture` alone does not opt out. The caller owns the positions and is a new token's creator.
`protocolShareBps` must meet `minProtocolShareBps()`, or the treasury's if higher. `launchWithBuy` adds a
creator buy, `launchAdvised` an advisory, `launchFamily` per-pool settings.

The release's Rules are closed to new pools here and the core's settings are packed: launch on hookr.fun or with `hookr_build_launch`.

## Claim

```
core.claimable(currency, account) view returns (uint256)
core.claim(currency) returns (uint256)        // pays msg.sender
core.claimTo(currency, to) returns (uint256)  // pays to
```

Holder Pot pay is a claim once credited. A holder's days are credited on its next swap or a poke.

The pool's core (`PoolConfig`'s `rules`) credits what it owes an account (arb recapture rebates, royalties, integrator fees, partial-fill refunds) per currency across its
pools; read `claimable` there first.

## Safety checks

1. Quote before every swap, with a real minimum out; stop at 15% impact.
2. Read the guard window and every Hook Block before trading a new token.
3. Never sign what the simulation did not pass.
4. Figures are one block's read; re-read before relying on them.

Full docs: /docs and /llms.txt. Source and review: https://github.com/Hookr-fun/hookr-contracts.