Uniswap v4 · immutable · real ETH yield
Every swap
feeds your node
UniNodes is a token welded into a custom Uniswap v4 swap hook. It skims 6% of every trade at the AMM level and streams it as live ETH into per-holder node contracts. Deploy a node, get paid on every swap that follows.
The hook is the protocol
No staking contract. No treasury bot. No off-chain keeper. One Uniswap v4 hook taxes, accounts and distributes. If a swap happens, the hook already paid your node.
Any trade routes through the ETH / NODE pool. No special router, no allowlist.
The hook skims 6% of the input inside pool settlement and books it to the accumulator.
Split pro-rata across every live node.
Parked as ETH, swapped to NODE, burned.
Skimmed at the AMM level on buys and sells alike. It lives inside the pool — there is no path that escapes it.
Split pro-rata across every live node through the on-chain accumulator.
Parked as ETH, swapped to NODE and burned on every executeBuyback() call.
The hook surface, callback by callback
getHookPermissions()0xC4 BITMAPDeclares exactly four permission bits to the PoolManager: beforeSwap, afterSwap, beforeSwapReturnDelta and afterSwapReturnDelta. Every other bit is zero — the hook can touch swaps and nothing else.
Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
beforeSwap()RETURNS_DELTASkims 6% of the swap input via a positive specified delta. The trader's effective amount-in shrinks before the curve is touched, so the price impact is honest and the tax can never be routed around.
return (selector, toBeforeSwapDelta(tax, 0), 0);
afterSwap()RETURNS_DELTASettles the skim once the pool clears. Buys deposit ETH straight into the pool; sells park NODE in pendingNodeTax until swapAndDistribute() converts it. Then the accumulator moves.
accETHPerNode += (inflow * 1e18) / nodeCount;
enableTrading()ONE-WAY FLAGPublic swaps revert until the deployer flips this exactly once. After the flag is set there is no off switch — trading cannot be paused, throttled, rate-limited or reversed by anyone, ever.
tradingEnabled = true; // irreversible
Mint your own slice of orderflow
A node is a per-holder contract that captures a share of every future swap. Non-custodial, permissionless, and earning from the very next trade, never from past ones.
Hold to unlock
Every 0.1% of total supply you hold unlocks exactly one node slot. Stack supply, stack slots.
Bought, not airdropped
Your wallet must have bought NODE through the pool. Transfers and airdrops never qualify, sybils are priced out.
Pay the deploy fee
Nodes 1–10 cost 0.01 ETH, 11–20 cost 0.02, and so on. The earlier you deploy, the cheaper your node is forever.
More than a tax. A yield machine
The hook does the boring part — skim and split. Everything around it is engineered to make a deployed node worth more tomorrow than today.
Uptime accrual
A node is not static. The longer it stays deployed without being burned, the more distribution weight it accrues — capped, on-chain, impossible to fake by re-minting. Hold the line, out-earn the latecomers.
MEV-shielded skim
The 6% cut is captured inside beforeSwap, before searchers ever see the trade. No sandwich can front-run a node.
Auto-restake loop
Opt a node into the restake path and claimed ETH buys NODE, lifting your supply share and unlocking the next slot.
Reflexive buyback
Sell pressure feeds the 1% wedge. The harder it dumps, the more NODE executeBuyback() takes off the market.
Node constellation
A live map of all 2,614 nodes — each one pulses the instant the accumulator pays it. On-chain, and mesmerising.
2,614 nodes are live right now
Every deployed node is a public, claimable contract. The accumulator does not care who you are — it pays weight, deploy order and uptime. This is the current top of the book.
The deployer cannot rug you
Not because of a promise — because the functions to do it were never written. The contract is verified on Etherscan. Read it before you read this.
- ×Mint new NODE — there is no mint function past deploy
- ×Pause or throttle trading once enableTrading() is flipped
- ×Change the 6% rate, the 5/1 split, or any fee parameter
- ×Drain the distribution pool — ETH only moves on claim()
- ×Upgrade the hook — no proxy, no admin, no upgrade path
- ×Seize, freeze, or reassign a deployed node
Three functions. Each callable exactly once. After the third, the deployer key is as powerless as any other wallet.
setFactory()setPoolKey()enableTrading()The technical bit, unhidden
No vague tokenomics wheel. Here is exactly what the hook does and the numbers it does it with.
Why the tax lives in the hook, not the token
A transfer tax on the ERC-20 breaks aggregators, gets routed around, and flags every wallet. UniNodes moves the cut into the Uniswap v4 hook via beforeSwap with BEFORE_SWAP_RETURNS_DELTA. The skim happens inside the pool's settlement, on the specified delta — so the price curve is untouched and the tax cannot be escaped by clever routing.
The hook address is mined, not deployed blindly
Uniswap v4 encodes a hook's permissions in the low bits of its own address. The UniNodes hook address is CREATE2-mined until those bits exactly equal 0xC4 — beforeSwap, afterSwap and both return-delta flags, nothing else. The PoolManager rejects any hook whose address does not match the callbacks it implements, so the permission set is provable from the address alone.
How a node captures rewards from swap one
Distribution uses a single pull-based accumulator, accETHPerNode, scaled by 1e18. Each inflow does one O(1) update; each node stores the accumulator value at its mint block. A claim simply pays the delta. A freshly deployed node captures the very next swap — never a retroactive cent — which keeps the math honest and the gas flat no matter how many nodes exist.
Buys, sells, and the pendingNodeTax bucket
Buys deposit ETH straight into the distribution pool. Sells leave NODE behind in a pendingNodeTax bucket; anyone can call swapAndDistribute() to convert it to ETH and fan it out. The 1% wedge accrues separately and is realised when executeBuyback() swaps it to NODE and burns it — permissionless, callable by any wallet.