Overview
REFLEX is a Uniswap v4 hook that prices a swap by how expected it is. The hook keeps a small amount of state — a market memory — and compares every incoming swap with it. A swap that looks like what the market has been doing pays close to the floor fee. A swap that departs sharply from it pays more, and the memory then moves towards what it just saw.
Nothing is discretionary: there is no owner switch on the fee, no allowlist, and no off-chain input. The fee is a function of state that the pool itself produced.
Market memory
Three values carry the memory. Each one is an exponential moving average — cheap to store, cheap to update, and impossible to reset by a single trade.
- Expected size
- The size the pool has been seeing, in ETH terms. A swap far above or below it is unexpected.
- Flow
- Directional balance between −1 and +1. Persistently one-sided flow shifts it; a swap against the prevailing side is unexpected.
- Activity
- How busy the pool has been, normalised to 0 … 1. A burst inside a quiet stretch is unexpected.
After each swap the memory adapts towards the observation:
memory ← memory + α · (observation − memory), with a small
α so a single trade cannot rewrite it.
Surprise score
The three gaps between the swap and the memory are combined into one bounded number:
surprise = clamp( 0.55 · sizeGap + 0.30 · flowGap + 0.35 · activityGap , 0 , 1 )
Size carries the most weight because size is the part of a swap that moves the pool. The score is stateless in itself — it is only the distance between one swap and the memory at that moment.
Dynamic fee
The score is mapped onto the fee band with a mild convex curve, so ordinary trading stays near the floor and only genuinely unusual flow reaches the upper half of the band:
fee = 0.5% + surprise1.45 · 6.5%
- Floor
- 0.5% — the fee for flow the memory already expects.
- Ceiling
- 7% — reached only by flow far outside the memory.
The Fee Response figure on the front page draws this curve. The moving dot is the current state of the memory; the fading dots behind it are the readings just before.
Live data
The front page carries three live modules — Recent Trades, the Market Memory Trace and Fee History. They are not three feeds: one stream appends a swap once, and all three react to the same object, so they cannot drift apart.
- Source
- Uniswap v4 emits every swap from the singleton PoolManager. The site reads those logs directly, filtered by the REFLEX pool id.
- Applied fee
- The event carries the fee charged on that swap in hundredths of a bip — for a dynamic-fee hook that is the number the hook decided on. It is plotted as-is.
- Side and size
- The amounts are the swapper's deltas: a negative ETH delta means ETH went into the pool, which is a buy. Relative times come from block timestamps.
- Surprise
- The hook does not publish its score, so it is recovered by inverting the fee curve above — a reading of the applied fee, not a separate measurement.
- Trace
- The memory is reconstructed from the same swaps: an EMA of size, the running buy/sell balance, and the pool's pace measured against its own norm.
Requests go through a connected wallet when one is on mainnet, and otherwise through public JSON-RPC endpoints tried in order. If they all fail the modules hold their last values and the header reads reconnecting; nothing is ever invented to fill the gap.
Event topics are hashed from their signature at runtime rather than pasted in, so a wrong constant cannot silently return an empty feed.
Rewards
Fees collected by the hook are distributed to $RFLX holders and are paid in native ETH — not in $RFLX, and not in a wrapped or synthetic claim token. Rewards accrue continuously and are withdrawn when a holder chooses to claim; there is no lock and no staking contract.
Wallet & claiming
The front page connects through the injected EIP-1193 provider — MetaMask, Rabby, Coinbase Wallet, Brave and anything else that follows the standard. Connecting requests accounts, reads the chain id, and follows account and network changes. A session that is already authorised is restored on load without a prompt.
- Claim is gated
- The button stays inert until a wallet is connected, and remains inert on the wrong network or with nothing pending.
- No wallet installed
- Only a real injected wallet can connect — there is no demo session and no stand-in address. With none installed the button points to a wallet directory instead.
- Network
- Ethereum Mainnet. On any other chain the interface asks you to switch before claiming.
Parameters
- Token
- $RFLX
- Supply
- 1,000,000
- Network
- Ethereum Mainnet
- Venue
- Uniswap v4
- Fee band
- ≈ 0.5% — 7%, dynamic
- Rewards
- Native ETH
- Contract
- —
Status
The pool is not deployed yet, so there are no REFLEX swaps to read. Until a pool id is configured the live modules make no chain requests at all and run a preview instead — labelled preview · no pool configured in the header and preview values · not market activity beneath the feed. Those numbers illustrate how the mechanic behaves; they are not trading statistics, and no market activity is being claimed. Reward balances are simulated on the same terms. The moment the pool id and token address are filled in, every module switches to real logs and the preview can never run again.
$RFLX is an experiment in fee design. Nothing here is financial advice.