We’re looking for a senior builder who lives at the intersection of protocol engineering and DeFi product design. You’ll design, prototype, and productionize Uniswap v4 hooks that unlock new markets. Think: dynamic fee markets, JIT‑aware liquidity protections, programmable compliance for RWAs, solver/intents integrations, perps/credit primitives, and beyond.

Why this role exists

• Hooks are the frontier. Uniswap v4 turns AMM behavior into a programmable surface. The ecosystem needs more production ready hooks to go from tinkering to real usage.
• Builders need partners. High‑quality hooks require deep protocol knowledge and product instincts designing the onchain mechanics, the incentives, and a path to distribution.
• UF’s mandate: accelerate onchain trading activity and protocol support across Uniswap deployments. This role is central to that impact.

The work

• Bring product thinking for market‑tailored hooks: Ideate/incubate high‑leverage ideas across market segments: volatile pairs (ETH/USDx, xBTC/USDx), correlated/stable pairs (USDx–USDx), and order sizes from small retail to whales. Translate these insights into concrete hook specs with clear adoption and measurement plans.
• Architect & ship hooks: Own the full lifecycle from whiteboard to an audited mainnet deployment that advance the roadmap (fee dynamics, liquidity management, MEV/LVR capture, KYC/attestations, JIT, etc.).
• Author canonical patterns: Publish reference implementations, hook templates, and “living specs” that other teams can safely extend.
• Design with distribution in mind: Co‑create adoption plans with other defi protocols (lending/ ALMs/vaults), aggregators/routers, intent layers, asset issuers. Ship the adapters, simulators, and SDK glue to make integration easy.
• Own security & correctness: Threat model hooks, define invariants, fuzz and formally verify critical paths, and partner with external auditors.
• Data & feedback loops: Work with the data team to instrument events/metrics, write Dune/Flipside dashboards, and run controlled experiments to tune parameters (fees, tick ranges, JIT thresholds) based on observed flow, MEV, and LP PnL

A week in this role might look like

• Ideate, architect, and implement a new stable‑stable hook designed to win $100k+ trades (market‑share target, slippage/fee behavior, routing incentives, aggregator integration plan).
• Design abstractions for reusability and code hygiene. Upstream libraries into a canonical toolkit
• Pair programming and code reviews with an external team on a lending rehypothecation hook design and implementation.
• Write Foundry tests and fuzzers for beforeSwap/afterSwap invariants; benchmark gas and optimize with Yul where it pays.
• Coordinate with an aggregator on simulation support and revert reasons; land a PR to their router.

What success looks like

3 months

• Land one high‑leverage hook in audit or on testnet with credible distribution partners.
• Establish a metrics schema and dashboard framework for hook evaluation (LP PnL, orderflow capture, effective liquidity).

6 months

• 2 production hooks with measurable flow/TVL and zero critical incidents.
• Clear adoption playbooks for routers, wallets, and solver layers; at least 3 third‑party teams shipping on your patterns.
• Demonstrated LP or trader outcome improvements
• Moved the needle on core KPIs

Minimum qualifications

• 3+ years smart‑contract engineering, with 2+ years shipping production DeFi at protocol teams (DEX, lending, perps, bridges, market making infrastructure, oracles).
• Deep Solidity + EVM internals; strong with Foundry, fuzzing, property tests; comfort reading/implementing community smart contracts.
• Knowledge of the most common security pitfalls
• Deep and practical understanding of Uniswap v4 architecture (PoolManager, Hooks, singleton design, state scoping, callback surfaces).
• Practical understanding of Uniswap v3 concentrated liquidity model
• Strong understanding of liquidity routing infrastructure - aggregators, routers, and solvers
• Demonstrated product sense in DeFi: able to reason about incentives, MEV, LP/trader UX, and distribution realities.
• A portfolio of shipped, battle‑tested contracts and public design docs, posts, or talks.

Nice‑to‑have signals

• Shipped a v4 hook on mainnet with end‑to‑end readiness - doesn’t matter if it succeeded in attracting orderflow or not. Hands‑on learnings and production experience are desirable.
• Emphasis on scalable and organized testing suites. Test-driven design practices

How we work

• Product focused: Intentional about building for target markets instead of randomly throwing ideas. We believe there is no one DEX design that fits all use cases, so we approach markets with different lenses - Ethereum volatile pairs, stable‑stable pairs, BTC‑fi pairs, RWAs and also chain dynamics (Arbitrum vs Base vs Mainnet vs Unichain).
• Velocity w/ security as a feature: We focus on solving one problem at a time and shipping with high velocity, without compromising on security. Staged rollouts, clear escape hatches, no heroics.
• Small, senior squads: you’ll lead initiatives, not tickets.
• Data‑anchored decisions: ship → measure → iterate.
• Public goods stewardship: Like Ethereum core devs, we see ourselves as stewards of shared infrastructure. We design primitives with ecosystem adoption in mind, ensuring they are neutral, composable, and useful beyond just one chain.

Application prompts (short and telling)

Please include two things with your application:

• A hook idea you’d ship in the next 12 weeks. Explain why and how you would decide on this idea: how you map the market opportunity, define the target pair, trade segment, and reason through ecosystem router/aggregator integration.
  • Outline: state, which lifecycle callbacks you’d use (beforeInitialize/beforeSwap/afterSwap/… ), key invariants, and gas/MEV risks
• A link to a deployed DeFi contract & Github from a previous that facilitates valuable economic activity. What was the initial design, and how did it evolve as you observed market‑share dynamics?
  • While not all developers write multi-million dollar TVL contracts, we especially want to see DeFi insight, security, and the learnings you had along the way

Interview flow (what to expect)

• 30‑min intro: mandate & your portfolio walkthrough.
• Deep‑dive design exercise: scope a hook and discuss edge cases, tests, and rollout plan.
• Live code review: read a small v4 hook and identify risks; write 2–3 properties to fuzz.
• Security focused interview with Security collaborator.
• Product/strategy chat with Growth: adoption plan, partners, and metrics.
• Take home assignment: implement a hook involving flash accounting and provide a robust test suite