Upgrade recursive verification to Aztec v3.0.0-devnet.20251212

- Update all @aztec/* dependencies to 3.0.0-devnet.20251212
- Use bb_proof_verification::verify_honk_proof for proof verification
- Store vk_hash in PublicImmutable storage during initialization
- Read vk_hash from storage in increment function (per PR #18)
- Update proof size to 508 fields, VK size remains 115 fields
- Use PublicMutable for counters instead of EasyPrivateUint
- Update storage access pattern: self.storage.x
- Update enqueue pattern: self.enqueue_self.func()
- Use #[only_self] for public functions callable only by contract
- Fix registerContract API: use positional params (instance, artifact)
- Fix bb.js API: use deflattenFields for proof conversion
- Update README, CLAUDE.md, and EXPLAINER.md documentation

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: critesjosh

.github/workflows/recursive-verification-tests.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     env:
       AZTEC_ENV: sandbox
-      AZTEC_VERSION: 3.0.0-devnet.4
+      AZTEC_VERSION: 3.0.0-devnet.20251212
 
     steps:
       - name: Checkout repository

CLAUDE.md

@@ -52,7 +52,7 @@ aztec-examples/
 bash -i <(curl -s https://install.aztec.network)
 
 # Set specific version (examples may require different versions)
-aztec-up 3.0.0-devnet.4  # For recursive_verification
+aztec-up 3.0.0-devnet.20251212  # For recursive_verification
 aztec-up 2.0.2  # For starter-token
 ```
 
@@ -199,9 +199,10 @@ Key considerations:
 The recursive verification example demonstrates:
 
 - **Off-chain proof generation**: Noir circuits compiled and executed with Barretenberg
-- **On-chain verification**: Using `std::verify_proof_with_type` in Aztec contracts
-- **UltraHonk proving system**: Generates proofs with 457 field elements, verification keys with 115 fields
-- **Private state management**: Using `EasyPrivateUint` for private counters
+- **On-chain verification**: Using `bb_proof_verification::verify_honk_proof` in Aztec contracts
+- **UltraHonk proving system**: Generates proofs with 508 field elements, verification keys with 115 fields
+- **VK Hash Storage**: Verification key hash stored in `PublicImmutable` storage, readable from private context
+- **Public state management**: Using `PublicMutable` for per-user counters
 
 ### Token Pattern (starter-token)
 
@@ -245,7 +246,7 @@ easy_private_state = { git = "https://github.com/AztecProtocol/aztec-packages/",
 
 **Version Compatibility**: Different examples may use different Aztec versions:
 
-- `recursive_verification`: v3.0.0-devnet.4
+- `recursive_verification`: v3.0.0-devnet.20251212
 
 ### JavaScript/TypeScript Dependencies
 

recursive_verification/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-This is an Aztec-Noir project that demonstrates proof verification in Aztec contracts. It uses Aztec version 3.0.0-devnet.4 to verify Noir proofs within smart contracts on the Aztec network.
+This is an Aztec-Noir project that demonstrates proof verification in Aztec contracts. It uses Aztec version 3.0.0-devnet.20251212 to verify Noir proofs within smart contracts on the Aztec network.
 
 The project consists of:
 
@@ -67,11 +67,12 @@ bun recursion
 ### Contract (`contract/`)
 
 - **`src/main.nr`**: Aztec smart contract with:
-  - `initialize()`: Sets up counter with initial value for an owner
-  - `increment()`: Verifies a Noir proof and increments the counter
+  - `constructor()`: Sets up counter with initial value for an owner and stores the VK hash
+  - `increment()`: Verifies a Noir proof (reads VK hash from storage) and increments the counter
   - `get_counter()`: Reads current counter value for an owner
-- Uses Honk proof verification (457 field elements for proof, 115 for verification key)
-- Stores private counters using `EasyPrivateUint` from Aztec-nr libraries
+- Uses `bb_proof_verification::verify_honk_proof` for proof verification (508 field elements for proof, 115 for verification key)
+- Stores VK hash in `PublicImmutable` storage (readable from private context)
+- Stores public counters per user using `PublicMutable` from Aztec-nr libraries
 
 ### Scripts (`scripts/`)
 

recursive_verification/EXPLAINER.md

@@ -32,14 +32,14 @@ flowchart TB
     subgraph "3. Proof Generation"
         BYTECODE -->|Barretenberg| PROVER[UltraHonk Prover]
         INPUTS[Inputs: x=1, y=2] --> PROVER
-        PROVER -->|Generates| PROOF_DATA[Proof Data<br/>- Proof: 457 fields<br/>- VK: 115 fields<br/>- Public inputs]
+        PROVER -->|Generates| PROOF_DATA[Proof Data<br/>- Proof: 508 fields<br/>- VK: 115 fields<br/>- Public inputs]
         PROOF_DATA -->|Saved to| JSON[data.json]
     end
 
     subgraph "4. Smart Contract"
         CONTRACT[ValueNotEqual Contract<br/>contract/src/main.nr]
-        CONTRACT -->|Contains| VERIFY[verify_proof_with_type]
-        CONTRACT -->|Manages| STATE[Private Counter State]
+        CONTRACT -->|Contains| VERIFY[verify_honk_proof]
+        CONTRACT -->|Manages| STATE[Public Counter State]
     end
 
     subgraph "5. On-chain Verification"
@@ -135,14 +135,14 @@ fn main(x: Field, y: pub Field) {
 The contract has three main functions:
 
 ```rust
-// 1. Initialize with a starting counter value
-fn initialize(headstart: u64, owner: AztecAddress)
+// 1. Initialize with a starting counter value and VK hash
+fn constructor(headstart: Field, owner: AztecAddress, vk_hash: Field)
 
-// 2. Verify proof and increment counter
+// 2. Verify proof (VK hash read from storage) and increment counter
 fn increment(
     owner: AztecAddress,
     verification_key: [Field; 115],
-    proof: [Field; 457],
+    proof: [Field; 508],
     public_inputs: [Field; 1]
 )
 
@@ -157,7 +157,7 @@ fn get_counter(owner: AztecAddress) -> Field
 **Size breakdown**:
 
 - **Verification Key**: 115 field elements (~3.7KB)
-- **Proof**: 457 field elements (~14.6KB)
+- **Proof**: 508 field elements (~16.3KB)
 - **Public Inputs**: 1 field element (the value of y)
 
 ## 📝 Step-by-Step Code Breakdown
@@ -195,58 +195,60 @@ const vkAsFields = await barretenbergAPI.acirVkAsFieldsUltraHonk(vk);
 ### Step 2: Contract Verification (`contract/src/main.nr`)
 
 ```rust
-#[private]
+#[external("private")]
 fn increment(
     owner: AztecAddress,
     verification_key: [Field; HONK_VK_SIZE],  // 115 elements
-    proof: [Field; HONK_PROOF_SIZE],          // 457 elements
+    proof: [Field; HONK_PROOF_SIZE],          // 508 elements
     public_inputs: [Field; 1],                // Just 'y' value
 ) {
+    // Read VK hash from storage (stored during contract initialization)
+    let vk_hash = self.storage.vk_hash.read();
+
     // This is the magic line - on-chain proof verification!
-    std::verify_proof_with_type(
+    verify_honk_proof(
         verification_key,
         proof,
         public_inputs,
-        0x0,              // Key hash (0 for self-verification)
-        HONK_IDENTIFIER   // Proof system type (1 = UltraHonk)
+        vk_hash   // VK hash for verification
     );
 
-    // If proof is valid, increment the counter
-    let counters = storage.counters;
-    counters.at(owner).add(1, owner);
+    // If proof is valid, enqueue public function to increment the counter
+    self.enqueue_self._increment_public(owner);
 }
 ```
 
 ### Step 3: Deployment & Interaction (`scripts/run_recursion.ts`)
 
 ```typescript
-// 1. Connect to Aztec network
-const pxe = await createPXEClient("http://localhost:8080");
-
-// 2. Deploy the contract with initial counter = 10
-const contract = await Contract.deploy(
-  wallets.owner,
-  ValueNotEqualContractArtifact,
-  [10, wallets.owner.getAddress()], // Constructor args
-  "initialize"
+// 1. Connect to Aztec network and setup wallet
+const aztecNode = await createAztecNodeClient("http://localhost:8080");
+const testWallet = await TestWallet.create(aztecNode, config);
+
+// 2. Deploy the contract with initial counter = 10 and VK hash
+const contract = await ValueNotEqualContract.deploy(
+  testWallet,
+  10,                        // Initial counter value
+  accounts[0].item,          // Owner address
+  data.vkHash                // VK hash stored in contract
 )
-  .send()
+  .send(sendOpts)
   .deployed();
 
-// 3. Submit proof for verification
+// 3. Submit proof for verification (VK hash read from storage)
 const tx = await contract.methods
   .increment(
-    wallets.owner.getAddress(),
-    data.vkAsFields, // Verification key
-    data.proofAsFields, // The proof
-    data.publicInputs // Public input (y=2)
+    accounts[0].item,
+    data.vkAsFields,     // Verification key
+    data.proofAsFields,  // The proof
+    data.publicInputs    // Public input (y=2)
   )
-  .send()
+  .send(sendOpts)
   .wait();
 
 // 4. Check the counter increased
 const counter = await contract.methods
-  .get_counter(wallets.owner.getAddress())
-  .simulate();
+  .get_counter(accounts[0].item)
+  .simulate({ from: accounts[0].item });
 // Counter is now 11 (10 + 1)
 ```

recursive_verification/README.md

@@ -11,12 +11,12 @@ This project implements:
 - **Proof Generation**: Scripts to generate UltraHonk proofs using Barretenberg
 - **On-chain Verification**: Deployment and interaction scripts for proof verification on Aztec
 
-**Aztec Version**: `3.0.0-devnet.4`
+**Aztec Version**: `3.0.0-devnet.20251212`
 
 ## Prerequisites
 
 - [Bun](https://bun.sh/) runtime (v1.0 or higher)
-- [Aztec CLI](https://docs.aztec.network/getting_started/quickstart) (version 3.0.0-devnet.4)
+- [Aztec CLI](https://docs.aztec.network/getting_started/quickstart) (version 3.0.0-devnet.20251212)
 - Linux/macOS (Windows users can use WSL2)
 - 8GB+ RAM recommended for proof generation
 
@@ -61,7 +61,7 @@ bash -i <(curl -s https://install.aztec.network)
 ### Set Aztec to the correct version:
 
 ```bash
-aztec-up 3.0.0-devnet.4
+aztec-up 3.0.0-devnet.20251212
 ```
 
 This ensures compatibility with the contract dependencies.
@@ -108,7 +108,7 @@ This runs `scripts/generate_data.ts` which:
 
 - Executes the circuit with inputs x=1, y=2
 - Generates an UltraHonk proof using Barretenberg
-- Saves proof data to `data.json` (457 field elements for proof, 115 for VK)
+- Saves proof data to `data.json` (508 field elements for proof, 115 for VK)
 
 ## Deploy and Verify On-Chain
 
@@ -153,7 +153,7 @@ For a fresh setup, run these commands in order:
 bun install
 
 # 2. Setup Aztec
-aztec-up 3.0.0-devnet.4
+aztec-up 3.0.0-devnet.20251212
 
 # 3. Compile circuit
 cd circuit && aztec-nargo compile && cd ..
@@ -254,8 +254,9 @@ bun data
 
 1. **Circuit**: The Noir circuit in `circuit/src/main.nr` creates a zero-knowledge proof that two values are not equal
 2. **Proof Generation**: Barretenberg generates an UltraHonk proof from the circuit execution
-3. **Contract**: The Aztec contract uses `std::verify_proof_with_type` to verify the proof on-chain
-4. **Privacy**: The contract uses private state (`EasyPrivateUint`) to maintain counters secretly
+3. **Contract**: The Aztec contract uses `bb_proof_verification::verify_honk_proof` to verify the proof on-chain
+4. **VK Hash Storage**: The verification key hash is stored in contract storage during initialization and read during proof verification
+5. **Counter Management**: The contract maintains public counters per user using `PublicMutable` storage
 
 ## Additional Scripts
 

recursive_verification/bun.lockb

@@ -4,7 +4,5 @@ type = "contract"
 authors = ["Satyam Bansal"]
 
 [dependencies]
-aztec = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v3.0.0-devnet.4", directory = "noir-projects/aztec-nr/aztec" }
-value_note = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v3.0.0-devnet.4", directory = "noir-projects/aztec-nr/value-note" }
-easy_private_state = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v3.0.0-devnet.4", directory = "noir-projects/aztec-nr/easy-private-state" }
-bb_proof_verification = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v3.0.0-devnet.4", directory = "barretenberg/noir/bb_proof_verification" }
+aztec = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v3.0.0-devnet.20251212", directory = "noir-projects/aztec-nr/aztec" }
+bb_proof_verification = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v3.0.0-devnet.20251212", directory = "barretenberg/noir/bb_proof_verification" }

recursive_verification/contract/Nargo.toml

@@ -2,37 +2,29 @@ use aztec::macros::aztec;
 
 #[aztec]
 pub contract ValueNotEqual {
+    // Sizes for bb_proof_verification
     global HONK_VK_SIZE: u32 = 115;
-    global HONK_PROOF_SIZE: u32 = 492 + 16;
+    global HONK_PROOF_SIZE: u32 = 508;
 
     use aztec::{
-        macros::{functions::{external, initializer, internal}, storage::storage},
+        macros::{functions::{external, initializer, internal, only_self, view}, storage::storage},
         oracle::debug_log::debug_log_format,
         protocol_types::{address::AztecAddress, traits::ToField},
-        state_vars::{Map, PublicImmutable},
+        state_vars::{Map, PublicImmutable, PublicMutable},
     };
-    use bb_proof_verification::verify_ultrahonkzk_proof;
-    use easy_private_state::EasyPrivateUint;
+    use bb_proof_verification::verify_honk_proof;
 
     #[storage]
     struct Storage<Context> {
-        counters: Map<AztecAddress, EasyPrivateUint<Context>, Context>,
+        counters: Map<AztecAddress, PublicMutable<Field, Context>, Context>,
         vk_hash: PublicImmutable<Field, Context>,
     }
 
     #[initializer]
-    #[external("private")]
-    fn initialize(headstart: u64, owner: AztecAddress, vk_hash: Field) {
-        let counters = storage.counters;
-        counters.at(owner).add(headstart, owner);
-
-        ValueNotEqual::at(context.this_address())._set_vk_hash(vk_hash).enqueue(&mut context);
-    }
-
-    #[internal]
     #[external("public")]
-    fn _set_vk_hash(vk_hash: Field) {
-        storage.vk_hash.initialize(vk_hash);
+    fn constructor(headstart: Field, owner: AztecAddress, vk_hash: Field) {
+        self.storage.counters.at(owner).write(headstart);
+        self.storage.vk_hash.initialize(vk_hash);
     }
 
     #[external("private")]
@@ -43,20 +35,21 @@ pub contract ValueNotEqual {
         public_inputs: [Field; 1],
     ) {
         debug_log_format("Incrementing counter for owner {0}", [owner.to_field()]);
-        let vk_hash = storage.vk_hash.read();
-        verify_ultrahonkzk_proof(verification_key, proof, public_inputs, vk_hash);
-        ValueNotEqual::at(context.this_address()).emit_in_public(12345).enqueue(&mut context);
-        let counters = storage.counters;
-        counters.at(owner).add(1, owner);
+        let vk_hash = self.storage.vk_hash.read();
+        verify_honk_proof(verification_key, proof, public_inputs, vk_hash);
+        self.enqueue_self._increment_public(owner);
     }
 
+    #[only_self]
     #[external("public")]
-    fn emit_in_public(n: Field) {
-        context.push_note_hash(n);
+    fn _increment_public(owner: AztecAddress) {
+        let current = self.storage.counters.at(owner).read();
+        self.storage.counters.at(owner).write(current + 1);
     }
 
-    #[external("utility")]
-    unconstrained fn get_counter(owner: AztecAddress) -> Field {
-        storage.counters.at(owner).get_value()
+    #[view]
+    #[external("public")]
+    fn get_counter(owner: AztecAddress) -> Field {
+        self.storage.counters.at(owner).read()
     }
 }