Fee sharing hook on Ethereum

Uniswap v4 Hook Contract 0x2d9bf6a7f61b5166e3d65e3877303fe84c5da8cc on Ethereum · Fee sharing

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 in this single pool pays the same fixed, hard-coded fee that the hook splits between a vault and a dev address, while LPs can withdraw freely but may face a gate when adding liquidity.

How it works step by step

  • Charges a fixed fee on swaps, with the rate set by a hard-coded constant (FEE_BPS), and splits part of it to a vault (VAULT_BPS). The exact rates cannot be read from bytecode alone.
  • Holds collected fees as Uniswap v4 claim tokens, then later converts them to real tokens and sends them out through a public flush function.
  • Allows only one pool to be initialized with this hook, and appears to check an external oracle or token contract (mintOpen) before letting liquidity be added.
  • References fixed addresses (dev, vault, oracle, locker, upp) that look like immutable recipients or helper contracts.
Swap behaviour
On each swap the hook can take a cut of the swap amounts through return deltas, and records it as claim tokens held by the hook. The exact fee size is a hard-coded constant that is not visible without verified source.
Liquidity behaviour
Before liquidity is added the hook runs a check, which may depend on an external contract's state such as a mint-open flag. Remove-liquidity callbacks are disabled, so LPs can always withdraw freely.
Fee behaviour
A constant fee (FEE_BPS) is taken from swaps and split between a vault (VAULT_BPS share) and what is likely a dev address. The exact percentages are hard-coded but could not be decoded from bytecode.
Owner & admin controls
No owner-settable functions were found. Fee rates and recipients appear to be immutable constants. The public flush function sends accrued fees to fixed recipients.

Enabled Uniswap v4 callbacks

beforeInitialize, beforeAddLiquidity, beforeSwap, afterSwap, beforeSwapReturnDelta, afterSwapReturnDelta

beforeInitialize: allows the hook to be attached to only one pool; beforeAddLiquidity: checks whether adding liquidity is allowed; beforeSwap and afterSwap: compute and collect the swap fee; beforeSwapReturnDelta and afterSwapReturnDelta: let the hook deduct its fee from swap amounts.

Security & trust assessment

Risk level: medium, estimated (decoded bytecode, medium confidence).

Who controls it: No admin keys were found. Fixed recipient addresses receive the fees, and an external contract may control when liquidity can be added.

Risk to user funds: The hook can take a fixed but unverified share of each swap. LP principal cannot be locked or drained, because remove-liquidity callbacks are disabled.

Security findings

  • [low] Unverified swap fee deduction: The hook deducts a constant fee from swaps via return deltas. The rate is hard-coded but cannot be confirmed from bytecode.
  • [info] Liquidity add gating: Adding liquidity may be blocked depending on an external contract's state. Withdrawals are never affected.
  • [info] No admin setters: The contract is not a proxy and exposes no owner functions for changing fees or recipients.

Contract details

Verified source
No
Bytecode size
7,100 bytes
Upgradeable proxy
No
Detected patterns
erc6909-claims, liquidity-management, moves-currency, oracle, return-delta, self-unlock

Pools using Fee sharing hook