FewToken liquidity on Uniswap v4
Few Protocol wraps supported assets into ERC-20 FewTokens. These FewTokens can trade against other FewTokens or connect back to their underlying assets through Uniswap v4 wrapper hooks.
Ethereum integration at a glance
Network and deployment
| Network | Chain ID | FewFactory | PoolManager |
|---|---|---|---|
| Ethereum Mainnet | 1 | 0x7D86394139bf1122E82FDF45Bb4e3b038A4464DD | 0x000000000004444c5dc75cB358380D2e3dE08A90 |
Pool coverage
| Pool type | Pools | Hook | Recommended integration path |
|---|---|---|---|
| Standard FewToken trading pools | 16 | None | Index first through the existing uniswap-v4 source |
| FewToken wrapper pools | 9 | Token-specific Few Hook | Review as custom v4 Hooks; start with the included fwUSDC/USDC vectors |
Integrate the 16 standard pools first. They use the standard Uniswap v4 execution path and do not require hook-specific handling. Ring can provide test vectors for the remaining wrapper deployments. Contact [email protected].
Machine-readable integration files: manifest · JSON Schema · pool state and execution vectors · aggregator status · SHA-256 checksums
Hook artifacts: FewTokenHook ABI · FewUSDTHook ABI · FewETHHook ABI
The static manifest is the ingestion source. The status file is a reproducible snapshot, not a live-liquidity API.
This package is specific to FewToken liquidity on Ethereum Uniswap v4. Ring Swap is a different AMM and has separate multi-network deployment and pool references for Ethereum, BNB Smart Chain, HyperEVM, and MegaETH. Keep those Factory/pair records out of this v4 manifest so an integration cannot mix incompatible pool identities or execution paths.
Core contracts
| Component | Address |
|---|---|
| Chain ID | 1 |
| PoolManager | 0x000000000004444c5dc75cB358380D2e3dE08A90 |
| StateView | 0x7fFE42C4a5DEeA5b0feC41C94C136Cf115597227 |
| V4Quoter | 0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203 |
| Permit2 | 0x000000000022D473030F116dDEE9F6B43aC78BA3 |
Universal Router (2.0.0) | 0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af |
| FewFactory | 0x7D86394139bf1122E82FDF45Bb4e3b038A4464DD |
| Few Wrapped Token init code hash | 0x2bdba5734ddf754fb149ef1faa937956c52cfd1f24d68163a95f42d08ec06d38 |
The manifest keeps the router address and source version as separate fields. Integrators using a different router or adapter can still use the same PoolKeys, but must generate calldata for their own execution stack.
The FewToken addresses and decimals in this package come from the deployed contracts. Verify each wrapper through
FewFactory and read token(), factory(), symbol(), and decimals() onchain. The
status file records metadata and CREATE2 address checks at a fixed block.
Local or historical FewWrappedToken source files are not an address or metadata authority for this integration package.
Pool identity
A pool is identified by its complete PoolKey:
currency0
currency1
fee
tickSpacing
hooks
The pool ID is the hash of this key. Aggregators must keep every field exactly as published because changing the fee, tick spacing, currency order, or hook address identifies a different pool.
Primary FewToken pools on Ethereum
The 25 Ethereum mainnet pools below are Ring's primary FewToken pools on Uniswap v4. The set contains 16 FewToken trading pools and nine wrapper pools. Pools are listed alphabetically within each type; their order does not indicate priority.
The two pool types play different roles in a route. The FewToken trading pools carry the core FewToken liquidity and are standard Uniswap v4 concentrated-liquidity pools with no hook, so they require no hook-specific handling. The wrapper pools are optional route edges: each uses a token-specific Few hook to convert between an underlying asset and its FewToken, which lets a route start or end in the underlying asset. Wrapper-hook support is not required to quote or swap through the FewToken trading pools.
The manifest contains the same 25 pools, token symbols and decimals, FewToken underlying mappings, hook metadata,
complete PoolKey, initialization block, initialization transaction, initial sqrtPriceX96, and initial tick.
FewToken trading pools
These pools trade one FewToken against another through standard Uniswap v4 concentrated liquidity. They have no hook.
Wrapper pools
These pools connect an underlying asset with its FewToken representation through a token-specific wrapper hook.
Machine-readable integration manifest
The static manifest contains the complete integration package. Its top-level
tokens array records every PoolKey currency's symbol, decimals, and FewToken underlying. hookContracts records the
deployed contract type, address, source and ABI status. pools contains the exact PoolKeys and initialization events.
schemaVersion changes when the JSON structure changes. manifestVersion changes when a published integration
parameter changes. Validate the file against its linked JSON Schema and use the checksum file when caching it. Each
pool also has an integrationPath field that distinguishes generic v4 ingestion from custom-Hook review. The
currency0 and currency1 order is part of the PoolKey; it is not a base/quote preference.
Quoting FewToken trading pools
Read each pool through its exact PoolKey and the current PoolManager state. A quote must account for the current
square-root price, active liquidity, initialized ticks, LP fee, swap direction, and requested amount.
The trading pools use standard Uniswap v4 fee units:
100means 0.01%500means 0.05%3000means 0.3%
Use the v4 Quoter or an equivalent state-simulation path. A recognized token or pool ID is not sufficient if the quote engine cannot read the pool, simulate the swap, and return an executable result.
Few wrapper hooks
Seven deployments use the generic FewTokenHook, the USDT deployment uses FewUSDTHook, and the native-ETH
deployment uses FewETHHook. Names such as FewUSDCHook or FewDAIHook are deployment labels, not Solidity contract
types.
All nine deployed addresses report the same permissions:
| Enabled callback or return-delta flag | Behavior |
|---|---|
beforeInitialize | Requires the exact underlying/FewToken pair and fee 0 |
beforeAddLiquidity | Allows the operation; it does not wrap liquidity deposits |
beforeSwap | Wraps or unwraps the swap-side token |
beforeSwapReturnDelta | Returns the conversion-aware delta to PoolManager |
All other hook flags are disabled, including both remove-liquidity callbacks. Wrapper conversion occurs during swaps, not when liquidity is added or removed.
The listed wrapper pools use:
fee: 0 (0%)
tickSpacing: 1
initial sqrtPriceX96: 79228162514264337593543950336
initial tick: 0
hookData: 0x
Quote both directions with the exact PoolKey. The conversion is designed around a 1:1 wrapper path, but the quote
engine should use the hook's returned deltas instead of hardcoding an output amount. Contract state, token behavior,
protocol charges, gas, or product-specific fees can still affect execution.
The ETH wrapper pool uses native ETH, represented by address(0), as currency0. WETH is used inside
FewETHHook; it is not a currency in that pool's PoolKey.
Wrapper pools can be used as route edges. An aggregator can wrap an input asset, trade through one or more FewToken
pools, and unwrap the output in the same route. Calldata must include the exact PoolKey, direction, amount,
slippage protection, and hookData required by the execution path.
Integration scope by pool type
| Scope | Pools | Recommended treatment |
|---|---|---|
| Standard FewToken trading pools | 16 | Ingest through the aggregator's generic uniswap-v4 source |
| ERC-20 wrapper pools | 8 | Review as custom v4 Hooks; start with the included fwUSDC/USDC vector |
| Native ETH wrapper pool | 1 | Review as a custom v4 Hook; verified source and ABI are published, and Ring can provide an ETH-specific execution vector |
Verified source and ABI are necessary for custom-Hook review, but they do not prove that 0x, KyberSwap, 1inch, or any other aggregator supports both execution directions. Confirm support with reproducible quote and calldata vectors for the exact wrapper PoolKey.
Pool state and execution checks
Read current pool state through StateView and simulate the requested trade size before execution. If an integration
depends on Ring's LP positions, also read their ownership and liquidity through PositionManager. A pool listing or
historical nonzero liquidity does not establish current depth or price quality.
The snapshot appendix contains quote and execution examples for both directions of one trading pool and one wrapper pool, plus historical pool-state and LP-position checks. The status file includes their block numbers, timestamps, and calldata.
Aggregator integration status
Aggregator support changes independently from the static addresses. Confirm coverage for each target PoolKey and swap direction through fresh quotes and executable calldata. Treat partial-path results separately from all-pool coverage and production support.
Historical 0x, KyberSwap, and 1inch observations are in the aggregator status file, with a check time for each entry. An API failure means unavailable during that check; it does not mean unsupported.
Source, ABI, and control assumptions
At block 25,851,888, the seven FewTokenHook deployments and the FewUSDTHook deployment matched
v4-periphery commit 31db16f7ebabe40827ab6dd1098d66840b7f80ad
after masking immutable constructor values. Their ABIs are linked at the top of this page.
The deployed FewETHHook was separately reproduced from
v4-periphery commit 0bc60b31c56d9115605b80720ceb8deb9c68b7ac
with Solidity 0.8.26, optimizer runs 44,444,444, and EVM target cancun. The compiled and deployed runtimes are
both 6,729 bytes and match after masking immutable constructor values. The exact deployed address also has
verified explorer source and ABI.
The matched hook source uses immutable PoolManager/token dependencies and exposes no owner, upgrade, fee, pause, or withdrawal administration. The underlying FewToken contracts, PoolManager, tokens, and router remain separate trust and integration dependencies.
No public professional audit report in the Ring v4-periphery repository names these Few hook deployments and an
exact source commit as its scope. The repository's existing ABDK report covers upstream v4 periphery and Universal
Router code, so it must not be cited as a Few-hook audit.
Integration completion criteria
FewToken liquidity support is complete when:
- all 25 listed pools can be discovered by their complete
PoolKey - the quote engine can read current pool state and return valid quotes when the pool supports the requested size
- a pool can enter the route when it improves the quote
- the router can produce executable calldata with the correct currencies, fee, tick spacing, hook, direction, amount, slippage protection, and hook data
- the integration can replay the published standard and wrapper vectors from the pinned block
- at least one mainnet transaction succeeds through a FewToken trading pool and at least one succeeds through a wrapper-hook pool
- the quote response or transaction trace identifies the FewToken pool or the aggregator's FewToken liquidity source
Support can ship in stages. Trading-pool support is a valid first release on its own because those pools require no hook handling. Wrapper-pool support completes the integration by adding underlying-asset entry and exit points to FewToken routes.
Protocol and contract references
- Uniswap v4 deployment addresses
- FewTokenHook and FewUSDTHook source at the verified reference commit
- FewETHHook source at the bytecode-matched commit
- Uniswap v4
PoolKey - Uniswap v4 Quoter
For ingestion questions, wrapper test vectors, or coverage confirmation, contact [email protected].
Appendix: quote and execution snapshots
These results apply to the recorded blocks. They are not live quotes or a guarantee of current liquidity. Re-query pool state and simulate the intended trade before execution.
Quote vectors
The status snapshot records V4Quoter calldata for both directions of
one standard pool and one wrapper pool at Ethereum block 25,851,888:
| Vector | Exact input | Output at block 25,851,888 |
|---|---|---|
fwUSDC -> fwDAI | 1 fwUSDC | 0.999320102450204966 fwDAI |
fwDAI -> fwUSDC | 1 fwDAI | 0.999429 fwUSDC |
fwUSDC -> USDC | 1 fwUSDC | 1 USDC |
USDC -> fwUSDC | 1 USDC | 1 fwUSDC |
The same file records sqrtPriceX96, tick, raw protocol-fee field, LP fee, and active liquidity for every one of the 25
Pool IDs. All 25 were initialized and had nonzero active in-range liquidity at the snapshot block. This is a state
check, not a TVL, depth, price-quality, or order-size guarantee.
Liquidity and Ring LP position snapshot
At Ethereum block 25,854,897, onchain reads of StateView and the Uniswap v4 PositionManager returned:
- initialized state and nonzero active in-range liquidity for all 25 published Pool IDs
- at least one nonzero PositionManager NFT owned by Ring's confirmed LP address in each of the 25 pools
- the expected owner and nonzero position liquidity for all 27 Ring-controlled target positions
The status file records the block timestamp and these results.
Position ownership establishes that Ring controlled LP positions in every listed pool at that block. It does not turn
activeLiquidity into TVL or guaranteed executable depth, or establish that ownership and liquidity remain unchanged.
Executable Universal Router vectors
The status file also contains complete execute(bytes,bytes[],uint256) calldata for the same four directions. Each
vector targets Universal Router 2.0.0, uses command V4_SWAP (0x10), and executes these v4 actions:
SWAP_EXACT_IN_SINGLE (0x06)
SETTLE_ALL (0x0c)
TAKE_ALL (0x0f)
The examples use a 50-basis-point minimum-output buffer, hookData=0x, value=0, and explicit ERC-20-to-Permit2 and
Permit2-to-router allowance requirements. The Permit2 approval is intentionally separate from the swap calldata; no
permit signature is embedded in the example.
Each calldata vector was replayed separately from the same starting state on a fork of block 25,851,888:
| Vector | Input spent | Output received | Fork gas used |
|---|---|---|---|
fwUSDC -> fwDAI | 1 fwUSDC | 0.999320102450204966 fwDAI | 129,809 |
fwDAI -> fwUSDC | 1 fwDAI | 0.999429 fwUSDC | 128,946 |
fwUSDC -> USDC | 1 fwUSDC | 1 USDC | 172,667 |
USDC -> fwUSDC | 1 USDC | 1 fwUSDC | 180,025 |
These are local-fork results, not mainnet transactions. Aggregators should replace the sample deadline and allowance flow with their production policy.
Mainnet execution references
- Standard pool
fwUSDR/fwDAI: successful transaction - Wrapper pool
fwUSDC/USDC: successful transaction
Both receipts contain a successful PoolManager Swap event for the named Pool ID. They record execution at their
respective transaction blocks; they do not identify an aggregator source or prove complete production support by
any aggregator.