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

# Hookr agent skill: Arbitrum

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=arbitrum`, 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 ETH, USDC, USDT0 or WETH in one call, arbitrage 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 ETH: /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: Arbitrum One, chain id 42161
- HOOKR is not on Arbitrum: a token there with that symbol is not HOOKR
- Public RPC: https://arb1.arbitrum.io/rpc
- Explorer: https://arbiscan.io
- Hookr is independent and not affiliated with or endorsed by Robinhood.
- Quotes: ETH, WETH `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`, USDC `0xaf88d065e77c8cC2239327C5EDb3A432268e5831`, USDT0 `0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9`. Bridged USDC.e is not one

## 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 its launcher's Multi-pool launches.
- HookrRoot: `0x89c9FB50d1f03192230FFB1c279BB6E7d3Fe6aCc`
- HookrRouter: `0xC2Bc9a3fe6c4Ce8C2F7EB4655b0869b01D8c93C9`
- HookrQuoter: `0x445D7891381Aa7F91F5048EdBC6a611ccBDe7865`
- HookrLauncher (existing tokens): `0x1cf2748A6670572425eAbf9Ab9e5BC4eb2eB8Ef4`. Use it for a token that already trades.
- HookrRegistry: `0x463c82beA1a52F4Cc05ca0741a24F0AD24bA4602`
- HookrTreasury: `0x2242F7FC75606500503075f29ea8cDA684EfB4a9`
- PoolManager: `0x360E68faCcca8cA495c1B759Fd9EEe466db9FB32`
- PositionManager: `0xd88F38F930b7952f2DB2432Cb002E7abbF3dD869`
- Permit2: `0x000000000022D473030F116dDEE9F6B43aC78BA3`

Universal Router: `0x8B844f885672f333Bc0042cB669255f93a4C1E6b`.

SDK: `npm install hookr-sdk viem`, /docs/pools/sdk. hookr-sdk 1.8.1 carries the release's addresses here as
`HOOKR_1_ARBITRUM` and the core as `rulesModule(HOOKR_1_ARBITRUM, "core")`, and builds quote and swap calls (`buildQuote`,
`buildSwap`, `swapAllowance`); your wallet signs.

## Pool key and pool id

```
PoolKey = {
  currency0: lower(subject, quote),  // numeric compare; 0x0 (ETH) 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: launch guard end, an Ethereum block, 0 = off
- `potBps` uint16: King of the Pool's share of what is left of arbitrage 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 block, 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 ETH. `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 arbitrage 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. Never a fixed limit: the floor follows the lane's cap.

## 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
launch guard is open only its `liquidityOwner` can add. `guardEndBlock` counts Ethereum
blocks: compare it with the latest block's `l1BlockNumber`, 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. With arbitrage recapture: `traderBps` 0, `lpBps` 10000, `releaseBlocks` 36000. To opt out, set bit 18 in `rules.potEveryNBuys` and zero `recapture`: zeroing it alone does not opt out. The caller owns the positions and creates a new token.
`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 (arbitrage 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 launch guard 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.
