Rex Roadmap: from chain interaction tool to full Ethereum development toolkit

[ilitteri]

Motivation

Rex currently covers ~25% of what a full Ethereum development toolkit offers, mostly chain interaction commands (balance, send, call, deploy, etc.). To become the go-to tool for Ethereum developers, we need to close critical gaps in compilation, testing, local development, and developer experience.

Rex has a unique strategic advantage: native L2 support powered by ethrex. No other tool has first-class deposit/withdraw/claim/batch/fee commands, and no other tool can spin up a local L1+L2 environment out of the box. The roadmap leans into this.

Phase 1 — Table Stakes

Low-hanging fruit that rounds out the chain interaction surface.

• rex build — standalone Solidity compilation (already compile during deploy — extract and expose)
• rex wallet — promote keystore to CLI: new, import, list, derive, remove
• rex to-wei / rex from-wei / rex to-unit — unit conversions (wei, gwei, ether, arbitrary decimals)
• rex gas-price / rex base-fee — query current gas price and block base fee
• rex estimate — estimate gas for a transaction
• rex block — full block info query (not just block number)
• rex storage — read raw storage slots from a contract
• rex logs — query event logs by signature, topic, address, block range
• rex rpc — raw JSON-RPC passthrough (any method)
• rex abi-encode — ABI encode without selector (complement to existing encode-calldata)

Phase 2 — The Moat (L2 + ethrex)

This is where rex becomes irreplaceable. No other tool can do this.

• rex node — launch ethrex as a local dev node (L1 mode, L2 mode, or L1+L2 together)
  • rex node — start local L1 node
  • rex node --l2 — start local L2 node (connected to local L1)
  • rex node --fork <url> — fork from mainnet
  • State manipulation RPCs (set balance, set storage, set code, impersonate)
  • Time/block manipulation, state snapshots, mining control
• rex test — Solidity testing framework
  • Unit tests, then fuzz and invariant testing
  • L2-specific cheatcodes: simulate deposits, withdrawals, batch verification
  • Fork testing, gas snapshots per test
• rex script — Solidity scripting: simulate locally → broadcast → verify in one flow
• rex init — project scaffolding with templates

Phase 3 — Developer Experience

Polish the development workflow.

• rex fmt — Solidity formatting
• rex debug — interactive step debugger (memory, stack, calldata view)
• rex coverage — code coverage reports (line, branch, function)
• rex snapshot — gas snapshot tracking with CI-friendly diff output
• rex flatten — flatten contract + dependencies into single file
• rex inspect — contract artifact inspection (ABI, storage layout, ASM, IR, method IDs)

Phase 4 — Ecosystem Polish

Round out the feature set for power users.

• rex resolve-name / rex lookup-address — ENS forward and reverse lookups
• rex 4byte — selector/signature lookups via openchain.xyz
• rex erc20 — full ERC-20 operations: name, symbol, decimals, supply, approve, allowance, mint, burn
• rex source — download verified source code from block explorer
• rex trace — replay and trace historical transactions locally
• rex deps — Solidity dependency management / package manager
• rex repl — interactive Solidity REPL with session caching and fork support
• rex proof — generate storage proofs
• rex access-list — generate EIP-2930 access lists
• rex disassemble — bytecode disassembly to human-readable opcodes
• rex bind — generate Rust bindings from ABI
• rex eip712 — generate EIP-712 struct encodings

Design Principles

1. One binary — everything is rex <command>, no separate tools
2. L2 native — every command that makes sense on L2 works with rex l2 <command>
3. ethrex powered — use ethrex internals for node, testing, debugging, tracing
4. Sane defaults — minimize required flags, auto-detect where possible
5. SDK parity — every CLI feature has a corresponding SDK function