Arbitrum Stylus Verifier | WakeUp Labs

[wakeuplabs]

Arbitrum Stylus verifier

Summary

Our project aims to develop a Stylus-compatible UltraHonk verifier that bridges the current gap between Noir's zero-knowledge capabilities and Arbitrum Stylus. We'll be refactoring Taceo Labs's rust implementation link which already is aligned with Aztec/Barretenberg v0.86.0 and incorporating design patterns that abstract platform. Beyond technical details, we're committed to creating comprehensive resources to drive adoption: an open-source repository with clear documentation, practical examples and applications, step-by-step tutorials, and supporting CLI tooling to streamline the development process.

Motivation

Noir proofs generated with Aztec's Barretenberg backend lack native verification support on Arbitrum Stylus. Although Barretenberg proofs can be verified using Solidity-based solutions, these verifiers are incompatible with Stylus's WebAssembly (WASM) environment.

After some research, we identified an existing Rust implementation of the UltraHonk verifier link. However, this implementation doesn't comply with the no_std policy of Stylus and does not use the ec precompiles.

Given this situation a complete reimplementation sounds prone to errors and more time consuming than setting us to fix the compatibility issues. Our approach will focus on systematically identifying these incompatibilities and addressing them, mostly removing std dependencies and leveraging precompiles through an adapter pattern which will even make it feasible to expand to more platforms in the future.
Beyond the technical implementation, we'll place significant emphasis on generating all the resources necessary for an optimized user experience that boosts adoption. This includes creating a comprehensive open-source repository with clear documentation, ensuring maintainability through robust testing and CI/CD pipelines, developing practical examples and step-by-step tutorials, and building additional tooling to streamline the development process. Our goal is to lower the barrier to entry and foster a thriving ecosystem around this technology.

Methodology

Our implementation will be split in 5 phases:

1. Refactor Taceo Labs Implementation to use an adapter pattern for the EC operations.
2. Remove STD dependencies and implement Stylus EC precompiles.
3. External audit, fixes and improvements.
4. CLI tooling.
5. Documentation, tutorials and examples.

Phase 1: Adapters pattern

Our objective in this phase is to refactor the verifier logic by introducing traits that abstracts elliptic curve arithmetic and pairing operations. We begin by implementing this trait using Arkworks, a well-established Rust cryptography library for BN254, which provides a reliable and fully local development backend. This allows us to verify the correctness of all operations off-chain, ensuring logic integrity before introducing environment-specific constraints.

Using Arkworks provides deterministic test results, seamless CI integration, and compatibility with no_std, enabling early portability validation. Once the verifier behavior is fully validated against known inputs and expected outputs, we can replace the trait implementation with one that targets Stylus. The trait interface is deliberately minimal—add, mul, and pairing using affine coordinates—yet expressive enough to support all UltraHonk cryptographic logic in a backend-agnostic manner, making future platform adaptations seamless.

Phase 2: Stylus compatibility

At this stage, our objective is to make the UltraHonk verifier compatible with the Stylus virtual machine. Stylus imposes strict constraints: no access to the Rust standard library (std) and execution via WASM with limited binary size. To meet these requirements without compromising correctness, we will finalize the implementation of a backend that performs elliptic curve operations using Ethereum precompiles (ecAdd, ecMul, ecPairing). This enables the verifier to delegate all cryptographic checks to Stylus-native syscalls, ensuring on-chain performance and security guarantees.

Simultaneously, we will eliminate any remaining std dependencies across the codebase. This means rewriting memory management, data structures, and error handling to rely exclusively on core and alloc. We will also remove all modules unrelated to the verification path (e.g., prover logic, CLI utilities) and ensure that everything compiles under no_std. These two streams of work—precompile backend and system-level portability—converge to produce a Stylus-deployable verifier that is lightweight, formally correct, and production-grade. No step proceeds without validation against Arkworks to ensure cryptographic equivalence at each layer.

Phase 3: External auditor

As mentioned in the disclaimer of the co-snarks repo we would be taking as a base, code is un-audited. To ensure maximum adoption for the generated codebase we want to add a layer of security for developers in auditing the final source code by an external agent. We’ll get some solid feedback from experts and add the fixes and improvements recommended.

Phase 4: CLI tooling

To streamline the developer experience and lower the barrier to entry, we will build a CLI tool that automates the full pipeline from Noir circuits to Stylus-compatible verification. Unlike Solidity-based workflows where the verification key (VK) is embedded during compilation, UltraHonk in Taceo requires the VK to be passed at runtime. Our tooling will reflect this dynamic model, allowing developers to generate a deployable verifier contract and invoke it by passing both the proof and the VK as arguments.

The CLI will support commands to compile a Noir circuit, generate the appropriate verifier wrapper for Stylus, and output the verifier as a WASM-compatible Rust contract that calls verify_proof(proof: Bytes, vk: Bytes) -> bool. Additional commands will help bootstrap a project, test it and deploy. By aligning with the Noir → Barretenberg → UltraHonk flow, and abstracting the complexity behind simple commands, we ensure the tool remains intuitive while adhering to UltraHonk’s stateless verification model.

Phase 5: Documentation and examples

We will produce complete project documentation covering the verifier architecture, its integration with Stylus, and the rationale behind each design decision. This includes concise developer-facing guides, tutorials for deploying Noir circuits with UltraHonk on Stylus, and implementation notes for contributors. Additionally, we will adapt a well-known Noir application for Stylus, providing reference implementations to demonstrate practical use cases of the verifier in real-world privacy-preserving applications.

Timeline and Deliverables

Right here we detail our plan to achieve the 5 phases in the ~3 months stipulated.

Phases	Description
1 (week 1-2)	Goal: Project kickoff. Fork and refactor Taceo Labs implementation with adapter pattern. Setup tests and automations. Deliverable: Well-tested adaptable version of Taceo Labs that abstracts away EC operations.
2 (week 3-7)	Goal: Implement ports for Arbitrum Stylus and remove all std dependencies. Deliverable: WASM-compilable version of UltraHonk.
3 (week 8)	Goal: External audit to check the code and identify performance or correctness issues. Deliverable: Audit report and implemented fixes.
4 (week 9-10)	Goal: Develop CLI tooling to automate verifier generation and deployment for Stylus. Deliverable: CLI tool published and functional.
5 (week 11)	Goal: Write documentation, usage guides, and adapt example Noir apps (e.g., Enigma, Privacy Pools) to Stylus. Deliverable: Guides, example apps, and live demos.

Team

At WakeUp Labs, we are committed to building secure, privacy-focused, and interoperable infrastructure for the blockchain ecosystem. Our work is rooted in open-source development and we bring deep technical expertise across chains and zero-knowledge technologies. Our team of experienced engineers consistently delivers high-quality tooling and research-grade implementations for the Web3 space.

Ecosystem alignment

Throughout our journey, we have actively collaborated with leading DAOs and projects, aligning closely with the goals of cutting-edge teams like Arbitrum and Noir. Some of our most impactful contributions include:

• Enigma – A private ERC-20 standard built on Starkware using Noir, enabling shielded transfers. Demo and source code
• Arbitrum Stylus SDK & CLI – Developer tools for building smart contracts with AssemblyScript. We’ve maintained and iterated on these tools alongside the community. via the forum, source-code.
• Aztec Sequencer Node – We’ve successfully run infrastructure contributing to the privacy-first rollup Aztec.
• Optimism Rollups as a Service – Contributed to rollup infrastructure and experimentation in the OP Stack. Source code
• BitcoinOS - Bridge in bitcoin using Circom circuits. Link
• Arbitrum Connect - Force include transactions when sequencer is down. Link

We actively share knowledge and code with the broader community and remain deeply engaged with the evolving Web3 landscape.

Team Members

We’ve assembled a team of senior engineers with deep Noir, Stylus and Rollup expertise.

• Franco Pérez – Senior Core Engineer

  • Co-developed Enigma, a private ERC20 developed with Noir for Starknet: starkware-private-erc20
  • Building AssemblyScript Stylus SDK: assembly-script-stylus
  • Honorable mention in the NoirHack Cookbook: noir-cookbook

• Matías Zapata – Senior Core Engineer

  • Co-developed Enigma, a private ERC20 developed with Noir for Starknet: starkware-private-erc20
  • Architected and Developed Rollup-as-a-Service for Optimism in Rust: op-ruaas

• Juan Dahl – Senior Core Engineer

  • Building AssemblyScript Stylus SDK: assembly-script-stylus

• Milton Berman – Founder & Engineer, WakeUp Labs

  • Oversaw all above projects
  • Presented Enigma at NoirCon Denver 2025: watch talk

Best practices

At WakeUp Labs, we follow rigorous engineering processes, prioritizing secure design, detailed documentation, and maintainable code. All our open-source contributions reflect our commitment to quality and transparency. As part of this we’ve committed to external audits for the project.

Start Date

9 June 2025

Questions

No outstanding questions at this time.

[wakeuplabs]

Changelog:
27 May 2025 · Added team members details to the proposal.