WakeUp Labs - Update Thread: Arbitrum Stylus Verifier

[WakeUpLabs]

TL;DR:

We’re building a Stylus-compatible UltraHonk verifier to bring Noir’s zero-knowledge proof system to Arbitrum Stylus. This bridges a critical gap for zk-dApps, enabling high-performance, WASM-based proof verification inside Stylus smart contracts.

Bridging Noir and Stylus

Our goal is to unlock native proof verification in Arbitrum Stylus for circuits built in Noir using Aztec’s Barretenberg backend.

Today, Stylus lacks native support for verifying UltraHonk zk proofs, which are commonly used in Noir-based circuits. At the moment, there are no Stylus-compatible implementations of the Barretenberg UltraHonk verifier backend that can take full advantage of Stylus’s performance and flexibility.

That being said, we did find a great Rust implementation by the Taceo team that mirrors the original C++ Barretenberg verifier almost 1:1, developed for their MPC use cases. Building on that, we set out to bring it to Stylus, making it WASM-compatible by removing std dependencies, isolating only the core verification logic, optimizing for size, and structuring it as a set of Stylus contracts that fully leverage Ethereum precompiles.

Milestone 1 & 2: Adapter Pattern + Stylus Compatibility, completed.

We’ve completed the first two phases of the project:

Milestone 1 focused on laying the groundwork.
Starting from Taceo Labs’ UltraHonk verifier (originally built for MPC scenarios), we removed all non-essential components and restructured the codebase around a clean adapter pattern. This pattern abstracts elliptic curve operations (add, mul, pairing) and hashing, letting us use Arkworks for local testing while preparing for Stylus integration.

We also set up a full repo environment with CI pipelines, covering linting, formatting, Stylus-specific checks, and tests execution on Nitro devnode.

Milestone 2 brought full Stylus compatibility.
We eliminated all remaining std dependencies and rewrote memory and error handling using core and alloc. The elliptic curve backend was implemented using Stylus-native precompiles (ecAdd, ecMul, ecPairing), ensuring correctness and on-chain efficiency.

We built and tested Stylus-compatible variants of the verifier (UltrahonkKeccak and ZkUltrahonkKeccak flavors) across three modular contracts to stay within WASM size limits. An integration test suite and GitHub Actions workflows were also added.

To tie it all together, we included a minimal “Hello World” demo project and documentation, readying the codebase for external audit.

Source code available here: github.com/wakeuplabs-io/noir-stylus-verifier

What’s Coming Next

With the foundation in place, we’re now focused on next steps:

Phase 3: Security Audit
We’ll bring in an external auditor to review the final codebase and suggest improvements, ensuring production-readiness and trust.

Phase 4: CLI Tooling
We’re building a CLI tool to help developers go from a Noir circuit to a Stylus-compatible verifier. The tool will support compiling circuits, generating wrapper contracts, and testing deployments.

Phase 5: Docs & Examples
We’ll publish clear documentation, practical examples, and tutorials, including real-world apps, such as voting and gaming, built entirely using Noir and Stylus to demonstrate end-to-end integration.

Why This Matters for the Arbitrum Ecosystem

This work brings Noir-based ZK circuits to Stylus. It enables on-chain proof verification using the most performant zero-knowledge backend available today (UltraHonk), expanding the range of apps that can be built on Arbitrum.

By ensuring compatibility and ease of use through CLI tooling and documentation, we’re making Stylus a go-to environment for zk developers.

---

We’ll be sharing updates and progress reports directly in the Arbitrum DAO Forum.
If you’re a developer working with Noir, zk circuits, or Stylus, we’d love your feedback as we build.
Thanks for following along!

Don’t forget to connect with us on X (Twitter) and LinkedIn for the latest updates.

[WakeUpLabs]

WakeUp Labs – Final Update: Arbitrum Stylus Verifier using Noir

TL;DR

We’ve delivered a Stylus-compatible UltraHonk verifier, CLI tooling, documentation, and full example applications. Now zk-dApps built with Noir can now run natively on Arbitrum Stylus.

Wrapping Up: CLI, Examples, and Review

Milestone 4 – CLI Tooling

We built a CLI tool to make it simple for developers to deploy Noir circuits in Stylus. It automates the full flow Noir → Barretenberg → UltraHonk → Stylus.

Commands supported:

• new → bootstrap a Noir project
• generate → compile circuits, export VK, generate Stylus contracts
• check → run stylus check for the generated verifier
• deploy → deploy verifier contracts
• prove → generate proofs (wrapping bb)
• verify → validate proofs locally or via deployed contracts

Deliverables:

• Source: Repo

Milestone 5 – Documentation & Examples

In this milestone, we focused on making the verifier practical and accessible for developers by delivering both example applications and a public documentation site.

We built an end-to-end example dApp, implemented with both a CLI and a web interface, to demonstrate real-world zk workflows on Stylus.

Battleship Game
A more interactive application showcasing zk-gaming. Players prove moves without revealing positions, demonstrating the potential of Stylus for privacy-preserving games.

Battleship: Arb Stylus Demo

Here’s the step-by-step guide on how to build this game: Building ZK Battleship with Noir and Stylus

Alongside this example, we launched a dedicated documentation site to support developers adopting this workflow:

nsv.wakeuplabs.link

Milestone 3 – Internal Review

We focused on an in-depth internal review, improving error handling, documentation, and applying fixes.

Deliverable: Review Report

Why This Matters

This project brings Noir’s zero-knowledge circuits into Stylus, enabling native proof verification directly inside WASM contracts. By integrating the UltraHonk backend with Stylus precompiles, developers now have access to a performant and production-ready verifier that can be deployed on Arbitrum today. Beyond the technical breakthrough, the CLI tooling, documentation, and example applications drastically lower the barrier to entry, turning what was once a highly complex workflow into something that can be reproduced with just a few commands. This combination of infrastructure and developer experience expands the design space for zk-applications on Arbitrum, opening the door to privacy-preserving governance, verifiable gaming mechanics, and new classes of DeFi protocols. In practice, the verifier makes Stylus a more attractive environment for zk developers.

Project Completion & Next Steps

With the delivery of Milestones 3, 4, and 5, this project has officially reached completion. We now have a fully functional Stylus-compatible UltraHonk verifier, a streamlined CLI toolchain, public documentation, and concrete example dApps that showcase how Noir circuits can be deployed and used in real-world scenarios on Arbitrum.

We want to thank the Arbitrum DAO and the community for supporting this work and following along with our progress. The verifier and tools are open-source, and we invite developers to experiment, contribute, and help shape the next wave of zk-dApps on Arbitrum.

Full repo: github.com/wakeuplabs-io/noir-stylus-verifier