Pelt on Robinhood Chain

Uniswap v4 Hook Contract 0x8c03970377abf7be0b50dabcd73a7f3fd33b20cc on Robinhood Chain · Custom pricing · Verified contract

Volume (24h)
$0
Value locked (TVL)
$0
All-time volume
$0
Pools using this hook
1
Swaps (24h)
0 (0 traders)
Total swaps
0

What it does

Every swap through the coin's ETH pool pays a fixed toll of 0.75 to 5 percent in ETH, taken on both buys and sells, with the toll split across four keeper-controlled caches and no liquidity or admin fee changes possible.

How it works step by step

  • Acts as the ERC20 token itself and the hook of its own Uniswap v4 pool paired against native ETH (currency0 is ETH, currency1 is the coin), with a fixed fee of zero and tick spacing 1.
  • Takes a toll of 75 to 500 bps (set at deployment, immutable) on every swap through the home pool, paid in ETH and returned to the PoolManager as an ERC-6909 claim minted to the hook.
  • Splits each toll across four caches: 80% to the breeder side (split between breeder and pack by creditsBps), 10% to the range cache, and the remainder to the den cache.
  • Lets only the keeper of each cache call empty(), which burns the matching claim and sends the ETH to that keeper.
  • Leaves all liquidity callbacks and donate callbacks reverting with NotWired, so liquidity can only come from the standard PoolManager flow without hook logic.
  • Mints a fixed supply of one billion tokens to the Kennel at deployment and renounces ownership in the constructor, so owner() returns zero.
Swap behaviour
Every swap through the home pool pays a toll of tollBps (75 to 500 bps) on the ETH side. For buys with exact ETH in, the toll is cut from the ETH sent before the pool swap. For sells with exact ETH out, the pool is asked for a grossed-up ETH amount and the toll is the difference. For legs that name the coin amount, the toll is computed in afterSwap from the ETH actually moved, and a partial fill reverts. Swaps through any other pool revert with StrangeBurrow.
Liquidity behaviour
All add and remove liquidity callbacks revert with NotWired, so the hook does not take fees or alter liquidity on those paths. Liquidity is only added or removed through the PoolManager directly, and those calls reach these reverting callbacks if the hook is consulted.
Fee behaviour
The pool uses a static fee of zero. The hook takes its toll through return deltas rather than the LP fee, at tollBps on the ETH leg of each swap. Buyers paying with exact ETH and sellers taking exact ETH out both pay the toll; the toll is ETH-denominated and does not depend on swap direction beyond which leg is tolled in which hook.
Owner & admin controls
No pause, no blacklist, no transfer tax, no mutable addresses. Ownership is renounced in the constructor so owner() is zero. The keepers of the four caches (breeder, pack, range, kennel) can each empty their own cache. There are no upgrade paths and tollBps and creditsBps are immutable.

Enabled Uniswap v4 callbacks

beforeInitialize, beforeSwap, afterSwap, beforeSwapReturnDelta, afterSwapReturnDelta

beforeInitialize: restricts initialisation of the single home pool to the Kennel with the canonical key. beforeSwap: computes and returns the toll as a before-swap delta for exact-in buys and exact-out sells. afterSwap: computes and returns the toll as an after-swap delta for coin-named legs once the ETH figure is known. beforeSwapReturnDelta and afterSwapReturnDelta: allow those deltas to take the toll from the swap.

Security & trust assessment

Risk level: low (verified source, high confidence).

Who controls it: No owner or admin can change fees, pause swaps or upgrade the hook. The only privileged actors are the four cache keepers, who can withdraw ETH from their own cache at any time.

Risk to user funds: The hook holds ETH only as an ERC-6909 claim inside the PoolManager and does not hold user coin balances outside normal ERC20 transfers; tolls are taken on every swap through the home pool and cannot be blocked by the hook, and the toll amount is fixed at deployment.

Security findings

  • [info] Hook takes ETH via return deltas: beforeSwap and afterSwap return deltas that move a toll of 75 to 500 bps of ETH on every swap through the home pool, so traders pay the toll on each leg.
  • [info] Immutable parameters and renounced ownership: tollBps, creditsBps, cache keepers and the pool manager are immutable and ownership is renounced in the constructor, so no privileged key can raise the toll or change the destinations after deployment.
  • [info] Cache keepers can drain their own cache: Each keeper address can call empty() for its cache and receive the ETH claim, so the four keepers hold the accumulated tolls once they are stashed.
  • [info] Partial fills revert: afterSwap reverts with PartialFill when a coin-named leg does not move the expected ETH, so a non-fully-filled swap through the home pool fails rather than taking an incorrect toll.

Contract details

Verified source
Yes (Pelt)
Compiler
solc 0.8.26+commit.8a97fa7a
Bytecode size
8,099 bytes
Upgradeable proxy
No
Detected patterns
erc20, moves-currency, ownable, return-delta, self-unlock, tax

Pools using Pelt