Split locks

Author: MauroToscano

contracts/lib/risc0-ethereum

@@ -0,0 +1,123 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+### Rust Workspace
+- **Build all crates**: `cargo build` (from `/crates` directory)
+- **Build specific crate**: `cargo build --manifest-path ./crates/[crate-name]/Cargo.toml`
+- **Build with release optimization**: `cargo build --release`
+
+### Batcher
+- **Build**: `cargo build --manifest-path ./crates/batcher/Cargo.toml --release`
+- **Run**: `cargo run --manifest-path ./crates/batcher/Cargo.toml --release -- --config ./config-files/config-batcher.yaml --env-file ./crates/batcher/.env`
+- **Start locally**: `make batcher_start_local`
+
+### CLI
+- **Build**: `cd crates/cli && cargo build --release`
+- **Install**: `cargo install --path crates/cli`
+- **Install script**: `./crates/cli/install_aligned.sh`
+
+### SDK
+- **Build**: `cargo build --manifest-path ./crates/sdk/Cargo.toml`
+- **Test**: `cargo test --manifest-path ./crates/sdk/Cargo.toml`
+
+## Testing Commands
+
+### Rust Tests
+- **Run all tests**: `cargo test` (from `/crates` directory)
+- **Run specific crate tests**: `cargo test --manifest-path ./crates/[crate-name]/Cargo.toml`
+- **Run with release mode**: `cargo test --release`
+
+### Go Tests
+- **Run all Go tests**: `go test ./... -timeout 15m`
+- **Run retry tests**: `cd core/ && go test -v -timeout 15m`
+
+### FFI Tests
+- **SP1 Rust FFI**: `cd operator/sp1/lib && RUST_MIN_STACK=83886080 cargo test --release`
+- **RISC Zero Rust FFI**: `cd operator/risc_zero/lib && cargo test --release`
+- **Merkle Tree FFI**: `cd operator/merkle_tree/lib && RUST_MIN_STACK=83886080 cargo test --release`
+
+## Linting Commands
+
+### Solidity Contracts
+- **Lint contracts**: `cd contracts && npm run lint:sol`
+
+### Rust (via Makefile targets)
+- Check individual crate formatting: `cargo fmt --check --manifest-path ./crates/[crate-name]/Cargo.toml`
+- Check individual crate linting: `cargo clippy --manifest-path ./crates/[crate-name]/Cargo.toml`
+
+## Common Development Commands
+
+### Dependencies
+- **Install all dependencies**: `make deps`
+- **Install Go dependencies**: `make go_deps`
+- **Initialize submodules**: `make submodules`
+
+### Development Environment
+- **Start Anvil**: `make anvil_start`
+- **Start full local environment**: `make setup_local_aligned_all`
+- **Build all FFIs**: `make build_all_ffi`
+
+### Proof Submission
+- **Send SP1 proof**: `make batcher_send_sp1_task RPC_URL=http://localhost:8545 NETWORK=devnet`
+- **Send RISC0 proof**: `make batcher_send_risc0_task RPC_URL=http://localhost:8545 NETWORK=devnet`
+- **Send Gnark proofs**: `make batcher_send_gnark_plonk_bn254_task RPC_URL=http://localhost:8545 NETWORK=devnet`
+
+## Architecture Overview
+
+### Core Components
+
+**Aligned Layer** is a verification layer for zero-knowledge proofs built on EigenLayer. The system consists of several key components:
+
+1. **Batcher** (`crates/batcher/`): Aggregates multiple proofs into batches for efficient verification
+   - Listens for WebSocket connections from clients
+   - Collects verification data and batches them based on time/size thresholds
+   - Submits batches to the verification layer
+
+2. **SDK** (`crates/sdk/`): Provides client libraries for interacting with Aligned Layer
+   - **Verification Layer**: Core verification functionality
+   - **Aggregation Layer**: Handles proof aggregation modes
+   - **Communication**: Protocol implementations for client-server communication
+   - **Ethereum Integration**: Smart contract interfaces and utilities
+
+3. **CLI** (`crates/cli/`): Command-line interface for submitting proofs and interacting with the system
+   - Proof submission with various proving systems (SP1, RISC0, Gnark, Circom)
+   - Balance queries and verification status checks
+   - Batch verification data handling
+
+4. **Task Sender** (`crates/task-sender/`): Utility for load testing and automated proof submission
+   - Wallet generation and funding
+   - Infinite proof submission with configurable parameters
+   - Connection testing utilities
+
+### Supported Proving Systems
+
+The system supports multiple zero-knowledge proving systems:
+- **SP1**: Succinct's zkVM proving system
+- **RISC Zero**: General-purpose zkVM
+- **Gnark**: Groth16 and PLONK protocols (BN254, BLS12-381)
+- **Circom**: Circuit compiler with Groth16 backend
+
+### Key Architectural Patterns
+
+1. **Modular Design**: Each component (batcher, SDK, CLI) is a separate crate with clear boundaries
+2. **Async/Await**: Heavy use of Tokio for asynchronous operations
+3. **FFI Integration**: Foreign function interfaces for integrating with Go-based verifiers
+4. **EigenLayer Integration**: Built as an AVS (Actively Validated Service) on EigenLayer
+5. **Multi-Network Support**: Configurable for different networks (devnet, testnet, mainnet)
+
+### Development Workflow
+
+1. **Local Development**: Use `make anvil_start` to start local blockchain
+2. **Component Testing**: Each crate can be built and tested independently
+3. **Integration Testing**: Full system testing using Docker compose or Makefile targets
+4. **Proof Generation**: Scripts in `scripts/test_files/` for generating test proofs
+
+### Configuration Management
+
+- **YAML Configuration**: Primary configuration files in `config-files/`
+- **Environment Variables**: `.env` files for sensitive configuration
+- **Network-Specific Config**: Separate configurations for different networks
+- **Makefile Parameters**: Extensive use of Make variables for configuration

contracts/lib/sp1-contracts

@@ -18,7 +18,7 @@ use tokio_tungstenite::{
 pub(crate) type WsMessageSink = Arc<RwLock<SplitSink<WebSocketStream<TcpStream>, Message>>>;
 
 pub(crate) async fn send_batch_inclusion_data_responses(
-    finalized_batch: Vec<BatchQueueEntry>,
+    finalized_batch: &[BatchQueueEntry],
     batch_merkle_tree: &MerkleTree<VerificationCommitmentBatch>,
 ) -> Result<(), BatcherError> {
     // Finalized_batch is ordered as the PriorityQueue, ordered by: ascending max_fee && if max_fee is equal, by descending nonce.

crates/CLAUDE.md

@@ -100,7 +100,7 @@ pub struct Batcher {
     /// The general business rule is:
     /// - User processing can be done in parallel unless a batch creation is happening
     /// - Batch creation needs to be able to change all the states, so all processing
-    /// needs to be stopped, and all user_states locks need to be taken
+    ///   needs to be stopped, and all user_states locks need to be taken
     batch_state: Mutex<BatchState>,
     user_states: DashMap<Address, Arc<Mutex<UserState>>>,
     /// When posting a task, this is taken as a write to stop new threads to update
@@ -1317,68 +1317,9 @@ impl Batcher {
             finalized_batch.len()
         );
 
-        // PHASE 1.5: Update user states immediately after batch extraction to make the operation atomic
-        // We assume the batch posting will be successful, so we update user states now
-        if let Err(e) = self.update_user_states_after_batch_extraction(&batch_state_lock).await {
-            error!("Failed to update user states after batch extraction: {:?}", e);
-            // We could potentially put the batch back in the queue here if needed
-            *batch_posting = false;
-            return None;
-        }
-
         Some(finalized_batch)
     }
 
-    /// Updates user states after successful batch submission.
-    /// This function should be called only AFTER the submission was confirmed onchain.
-    /// Note: Proofs were already removed from the queue during the extraction phase.
-    async fn update_user_states_after_batch_submission(&self) -> Result<(), BatcherError> {
-        info!("Updating user states after batch submission...");
-        let batch_state_lock = self.batch_state.lock().await;
-
-        // Calculate the new user_states based on the current queue (proofs already removed)
-        let new_user_states = self.calculate_new_user_states_data(&batch_state_lock.batch_queue);
-
-        let user_addresses: Vec<Address> =
-            self.user_states.iter().map(|entry| *entry.key()).collect();
-        let default_value = (0, U256::MAX, U256::zero());
-        for addr in user_addresses.iter() {
-            let (proof_count, max_fee_limit, total_fees_in_queue) =
-                new_user_states.get(addr).unwrap_or(&default_value);
-
-            // FIXME: The case where a the update functions return `None` can only happen when the user was not found
-            // in the `user_states` map should not really happen here, but doing this check so that we don't unwrap.
-            // Once https://github.com/yetanotherco/aligned_layer/issues/1046 is done we could return a more
-            // informative error.
-
-            // Now we update the user states related to the batch (proof count in batch and min fee in batch)
-            {
-                let user_state = self.user_states.get(addr);
-                match user_state {
-                    Some(user_state) => {
-                        let mut user_state_guard = user_state.lock().await;
-                        user_state_guard.proofs_in_batch = *proof_count;
-                        user_state_guard.last_max_fee_limit = *max_fee_limit;
-                        user_state_guard.total_fees_in_queue = *total_fees_in_queue;
-                    }
-                    None => {
-                        return Err(BatcherError::QueueRemoveError(
-                            "Could not update user state".into(),
-                        ));
-                    }
-                }
-            }
-        }
-
-        // Update metrics
-        let queue_len = batch_state_lock.batch_queue.len();
-        let queue_size_bytes = calculate_batch_size(&batch_state_lock.batch_queue)?;
-
-        self.metrics
-            .update_queue_metrics(queue_len as i64, queue_size_bytes as i64);
-
-        Ok(())
-    }
 
     /// Updates user states immediately after batch extraction to make the operation atomic.
     /// This function should be called right after extracting proofs from the queue.
@@ -1484,7 +1425,7 @@ impl Batcher {
     /// NOTE: Nonce ordering is preserved by the priority queue's eviction order:
     /// - Lower fees get evicted first
     /// - For same fees, higher nonces get evicted first  
-    /// This ensures we never have nonce N+1 without nonce N in the queue.
+    ///   This ensures we never have nonce N+1 without nonce N in the queue.
     async fn restore_proofs_after_batch_failure(&self, failed_batch: &[BatchQueueEntry]) {
         info!("Restoring {} proofs to queue after batch failure", failed_batch.len());
 
@@ -1651,7 +1592,7 @@ impl Batcher {
                 &batch_bytes,
                 &batch_merkle_tree.root,
                 leaves,
-                &finalized_batch,
+                finalized_batch,
                 gas_price,
             )
             .await
@@ -1686,7 +1627,7 @@ impl Batcher {
         // User states were also already updated atomically during extraction
 
         // Clean up user states for users who had proofs in this batch but now have no proofs left
-        self.cleanup_user_states_after_successful_submission(&finalized_batch);
+        self.cleanup_user_states_after_successful_submission(finalized_batch);
 
         connection::send_batch_inclusion_data_responses(finalized_batch, &batch_merkle_tree).await
     }