Explorers and indexers
Every event by contract, which one credits an account and in which field, the claim that pays it, and the views that answer what events do not.
On this page
Everything a Hookr pool pays is on chain and announced in events. This page lists the events by contract, says which event credits an account and in which field, and names the views that answer what events do not.
Where to start
Index HookrRoot, the shared hook, on Robinhood Chain. From there:
| Contract | How to find it |
|---|---|
| Each pool | PoolOpened on the root, or poolConfig(id) on it: the subject, the quote, its HookrRules, the advisory and the liquidity owner |
| Its HookrRules | The HookrRules address in that PoolOpened or in poolConfig(id). Each HookrRules keeps its own claims, so a pool's income is read at its own HookrRules and nowhere else |
| Its arb recapture lane | PoolLane on the root, or laneOf(id) on it: the executor, its code hash, the partner share and the lane family |
| Its launcher | launcher in that PoolOpened; on a pool launched through Hookr it is also the pool's liquidity owner |
| The protocol recipient | protocolRecipient() on the HookrRules: Hookr's treasury |
| The router | curatedRouter() on the root |
| The PoolManager | Uniswap v4's, on Contracts and addresses; its Initialize names the hook, and the pool id is the one the hook's events carry |
| Other roots | RootRegistered and FactoryRootRegistered on the registry; a hook you deploy emits its own PoolOpened |
Hookr's release contracts, the hook, the launcher, the router and the treasury among them, are on Contracts and addresses, verified on Sourcify as an exact match. A pool's own PoolOpened names the HookrRules and the launcher it uses, on Hookr's hook as on a hook you deploy.
Events by contract
| Contract | Events |
|---|---|
| HookrRoot | PoolOpened once per pool, with the pool id, its launcher, its policy hash, its HookrRules and its advisory; HookFee(id, quote, earned, refund, burned) per swap; PoolLane(id, executor, codeHash, partnerBps, family) once per pool with arb recapture; CorrectionSucceeded(id, phase, trader, reportedProfit, pushed, currency) and CorrectionFailed(id, phase, trader, reason) per arb recapture frame; LaneCodeChanged; ClaimsSwept(id, currency, amount) when the root's own claims are swept to a lane pool's HookrRules |
| Every HookrRules | RulesBound(id, root, configHash, config) once per pool; FeesAllocated(id, quote, protocol, royalty, refund, advisoryRecipient, advisoryFee) per swap and per executor leg's advisory take; IntegratorPaid(id, quote, integrator, amount) per swap on a pool with an integrator; Claimed(quote, beneficiary, to, amount) per claim |
| A HookrRules with arb recapture | RecaptureSplit(id, trader, traderAmount, lp, pot, protocol, currency, reportedProfit) per push; LpShareDonated(id, amount0, amount1) as the LP share is released; PoolAccrued(id, currency, amount) and PoolClaimed(id, to, currency, amount) for the liquidity owner's accrual; ClaimsSwept(currency, amount) for what the root swept in |
| A HookrRules with King of the Pool | LeaderChanged(id, leader, amount, epochStart); CrownVoided(id, voided, restored, epochStart); KingCrowned(id, winner, amount, epochStart); EpochRolled(id, closedEpochStart, nextEpochStart, potCarried); PotReleased(id, amount) |
| Hookr's core, on top of the above | CoreBlocksBound(id, word) once per pool; CoreBlockAllocated(id, payer, charge, outflow, recipient, amount) per swap that paid Swap Cut, Exit Clock, Storm Fee or Sandwich Guard; ExitRebated(id, seller, amount); SandwichRepriced(id, trader, amount); StormStepped(id, fromPips, toPips, variance); ExitRecordCut(id, wallet, poker, cut); HolderMoved, HolderCredited(id, wallet, amount), HolderForfeited, HolderPotClosed and HolderPotCarried for Holder Pot; PlaceChanged(id, place, account, amount, epochStart) and PlaceCrowned(id, place, winner, amount, epochStart) for a podium; PotToppedUp(id, from, amount, epochStart); Recapture |
| HookrRouter | SwapExecuted(poolId, payer, recipient, amountIn, amountOut) per swap; SwapRelayed(poolId, payer, feeRecipient, outputFee) for a relayed swap's fee; SwapGated(poolId, payer, gate, funder) for a gated swap; Swept |
| HookrLauncher | FamilyLaunched, MemberLaunched(familyId, member, poolId, quote, liquidity), DevBuyExecuted, LaunchFeePaid; LiquidityAdded, LiquidityRemoved and LPFeesCollected(familyId, member, poolId, owner, recipient, amount0, amount1) as the launch position moves; ClaimsRedeemed |
| HookrTreasury | ProtocolCollected(source, currency, to, amount) each time the treasury collects a HookrRules' protocol claim; ProtocolForwarded and Protocol for the delivery to its target |
| PoolManager | Uniswap's Initialize, Swap, ModifyLiquidity and Donate, keyed by the same pool id |
The HookrRules events come from its own address, the arb recapture and King of the Pool events included, and on Hookr's core the Hook Blocks run inside it, so a block's event comes from the core's address too. The lane events come from the root.
Three signatures are shared, so key every log by the contract that emitted it. Claimed(currency, beneficiary, to, amount) is also the referral distributor's; ClaimsSwept has a pool id on the root and none on a HookrRules; FeesAllocated is a swap's settlement on HookrRules and an executor leg's advisory take on HookrRecapture, with every amount but advisoryFee zero.
Who is credited, by which event
A HookrRules credits an account by adding to its claims in one currency. The event that records the credit carries the pool id, and the account it names is in the field below.
| Income | Credited to | Event and field |
|---|---|---|
| Hookr's share of a swap's block fees | the protocol recipient | Fees, what the protocol recipient kept |
| An integrator's rate of that share | the pool's integrator | Integrator and amount |
| The creator royalty on a buy | config(id).royaltyTo | FeesAllocated.royalty; the event names no recipient |
| A partial fill's refund | the swap's payer | FeesAllocated.refund; a swap through Hookr's router names the payer in SwapExecuted.payer in the same transaction |
| An advisory's fee, or an executor leg's advisory take | Fees | Fees |
| The trader's share of an arb recapture | RecaptureSplit.trader | Recapture, zero when no trader is paid |
| Hookr's cut of an arb recapture | the protocol recipient | Recapture |
| An integrator's slice of that cut, on Hookr's core | Recapture | Recapture |
| A King of the Pool prize | KingCrowned.winner, and on Hookr's core PlaceCrowned.winner | amount, in the pool's quote |
| Swap Cut, Exit Clock, Storm Fee or Sandwich Guard paid to the creator | Core: the liquidity owner's accrual at outflow 1, royaltyTo at outflow 4 | Core, net of Hookr's share; charge is 0 Swap Cut, 1 Exit Clock, 2 Storm Fee, 3 Sandwich Guard; outflow 2 feeds Holder Pot and 3 the King of the Pool pot, with no recipient |
| Exit Clock's rebate to a seller | ExitRebated.seller | ExitRebated.amount |
| A holder's Holder Pot earnings | HolderCredited.wallet | HolderCredited.amount |
| The liquidity owner's accrual, once moved | PoolClaimed.to | PoolClaimed.amount; the accrual itself was PoolAccrued |
| What the root swept | the protocol recipient | ClaimsSwept.amount on the HookrRules |
Two legs of an arb recapture are not claims. RecaptureSplit.lp is the pool's pending LP share, donated to its in-range liquidity by LpShareDonated or, with none in range, accrued to the liquidity owner by PoolAccrued; RecaptureSplit.pot goes into the King of the Pool pot, which KingCrowned, PlaceCrowned and PotReleased pay out later.
The liquidity owner's accrual moves into claims only when the liquidity owner calls claimPool(id, to). On a pool launched through Hookr the launcher is the liquidity owner, and the launch's owner moves it with claimRecapture(familyId, member, to), or with any withdraw or fee collection on the member.
Claims
Every credit is a claim: nothing is pushed to an account. The HookrRules holds one balance per currency and account, pooled across every pool on it, and claimable(currency, account) reads it.
| Call | What it does |
|---|---|
claim(currency) | Pays the caller's whole balance to the caller |
claimTo(currency, to) | Pays it to to |
claimAsClaims(currency, to) | Moves it to to as PoolManager ERC-6909 claims, for a quote that no longer transfers exact amounts |
Each one emits Claimed(currency, beneficiary, to, amount) with the caller as beneficiary, and a zero balance reverts with NothingToClaim. A balance above the PoolManager's signed 128-bit limit is paid in chunks, one per call.
One payment is not a claim: a relayed swap's outputFee goes to SwapRelayed.feeRecipient inside the swap.
The treasury is paid the same way. Anyone can call collect(source, currency) or collectTo(source, currency) on it, which calls claimTo on the HookrRules named as source, so one transaction carries its Claimed with the treasury as beneficiary and the treasury's ProtocolCollected.
Proving one account's income
- List the HookrRules the account was credited on. Each pool names its own in
poolConfig(id), and every credit event carries its pool id. - On each, sum the credit events above that name the account, by currency. The pool id is on the credit event.
- Check the sum against
claimable(currency, account)plus the account'sClaimedlogs there. The two agree. - Read
Claimed.tofor where the money went.beneficiaryis the account whose balance was paid.
Claimed names no pool, so a per-pool statement comes from the credit events and a per-account statement from Claimed. An account's LP income is not a claim: it reaches the position through LpShareDonated and the pool's base fee, and leaves through the PoolManager or the launcher's LPFeesCollected.
Views
| View | What it answers |
|---|---|
claimable(currency, account) on the HookrRules | The balance waiting to be claimed |
config(id) on the HookrRules | The pool's frozen settings: royaltyTo, integrator, potBps, protocolShareBps and the rest of its RulesConfig |
integration(id) on HookrRules | The pool's integrator and its rate |
protocolRecipient() and trustedRoot() on the HookrRules | The treasury the protocol share is credited to, and the one root that may settle |
recaptureConfig(id) and recaptureMode(id) on a HookrRules with arb recapture | The frozen recapture terms and pot share; 0 no recapture, 1 recapture, 2 with King of the Pool |
pendingPrize(id), and hill(id) and podium(id) on Hookr's core | What closing the round now would credit, the round's leader, spend and pot, and each place on the podium |
poolAccrued(id, currency) and poolAccruedCurrencies(id) | The liquidity owner's accrual not yet moved into claims |
poolConfig(id) and laneOf(id) on the root | The pool's configuration and its lane |
integrator(account) and feeTerms(integrator, recapture, id) on the treasury | An integrator's listed rate and the terms a new pool would freeze |
Block numbers and clocks
Logs and eth_getLogs use Robinhood Chain's own block numbers, and the LP share's release counts them too. RulesConfig.guardEndBlock and removalLockedUntil(id) are parent-chain blocks, and epochStart in the King of the Pool events is a timestamp.
The latest block's l1BlockNumber gives the parent-chain number to compare those with; eth_blockNumber gives Robinhood Chain's own.