docs: match the SP1 proof aggregation documentation style

Author: fakedev9999

book/advanced/prove-scripts.md

@@ -1,15 +1,26 @@
 # Prove Scripts
 
-The prove scripts allow you to manually generate range and aggregation proofs for OP Succinct. These are useful for testing proof generation workflows and debugging.
+The prove scripts allow you to manually generate range and aggregation proofs for OP Succinct.
 
 ## Overview
 
-There are two main proving binaries:
-- **multi.rs**: Generates range proofs for multiple blocks
-- **agg.rs**: Aggregates multiple range proofs into a single aggregation proof
+OP Succinct uses a two-tier proving architecture:
+
+1. **Range Proofs** (`multi.rs`): Generate compressed proofs for a range of L2 blocks. These proofs verify the state transition for a specific block range.
+
+2. **Aggregation Proofs** (`agg.rs`): Combine multiple range proofs into a single aggregation proof. This reduces on-chain verification costs by verifying one proof instead of many.
 
 Both binaries use the SP1 network prover by default.
 
+### When to Use Aggregation
+
+Aggregation is useful when you need to:
+- Reduce on-chain verification costs by combining multiple range proofs into one proof
+- Prove larger block ranges by aggregating individual range proofs from different time periods
+- Combine proofs from different proving sessions into a single proof for batch submission
+
+> **Note:** All range proofs must be generated in compressed mode for aggregation. The prove scripts handle this automatically.
+
 ## Setup
 
 ### Environment Configuration
@@ -74,7 +85,7 @@ AGG_PROOF_MODE=plonk             # Options: plonk, groth16
 
 ## Generating Range Proofs
 
-The `multi.rs` binary generates range proofs for a specified block range.
+The `multi.rs` binary generates compressed range proofs for a specified block range. These proofs verify the state transition function for the L2 blocks in the range.
 
 ### Usage
 
@@ -88,20 +99,29 @@ cargo run --bin multi --release -- \
 ### Example
 
 ```bash
-# Generate a range proof for blocks 1000-1300
+# Generate a compressed range proof for blocks 1000-1300
 cargo run --bin multi --release -- \
     --start 1000 \
     --end 1300 \
     --prove
 ```
 
+The proof will be generated in compressed mode, which is required for aggregation.
+
 ### Output
 
 Range proofs are saved to `data/{chain_id}/proofs/{start_block}-{end_block}.bin`
 
 ## Generating Aggregation Proofs
 
-The `agg.rs` binary aggregates multiple range proofs into a single aggregation proof.
+The `agg.rs` binary aggregates multiple compressed range proofs into a single aggregation proof. This allows you to verify the state transition for a large block range with a single on-chain verification.
+
+### How Aggregation Works
+
+1. The binary loads the specified range proofs from `data/fetched_proofs/`
+2. Each range proof is verified to ensure validity
+3. The proofs are aggregated into a single proof that attests to the entire block range
+4. The aggregation proof can be submitted on-chain for efficient verification
 
 ### Usage
 
@@ -115,27 +135,30 @@ cargo run --bin agg --release -- \
 ### Example
 
 ```bash
-# Aggregate three range proofs
+# Aggregate three consecutive range proofs covering blocks 1000-1900
 cargo run --bin agg --release -- \
     --proofs 1000-1300,1300-1600,1600-1900 \
     --prover 0x1234567890abcdef1234567890abcdef12345678 \
     --prove
 ```
 
+This will generate a single aggregation proof that verifies the state transition from block 1000 to 1900.
+
 ### Parameters
 
 | Parameter | Description | Required |
 |-----------|-------------|----------|
 | `--proofs` | Comma-separated list of proof names (without `.bin` extension) | Yes |
-| `--prover` | Prover wallet address | Yes |
-| `--prove` | Generate proof (omit to only execute) | No |
+| `--prover` | Prover wallet address included in the aggregation proof | Yes |
+| `--prove` | Generate proof (omit to only execute and verify inputs) | No |
 | `--env-file` | Path to environment file (default: `.env`) | No |
 
 ### Requirements
 
 - Proof files must exist in `data/fetched_proofs/` directory
 - Proof names should match the range format: `{start_block}-{end_block}`
-- All range proofs must be verified before aggregation
+- Range proofs must be consecutive (e.g., 1000-1300, 1300-1600, 1600-1900)
+- All range proofs are automatically verified before aggregation
 
 ## Local Development
 

scripts/prove/bin/agg.rs

@@ -67,7 +67,14 @@ fn load_aggregation_proof_data(
     (proofs, boot_infos)
 }
 
-// Execute the OP Succinct program for a single block.
+/// Aggregates multiple range proofs into a single proof.
+///
+/// This binary takes multiple compressed range proofs and aggregates them into a single
+/// aggregation proof. This is useful for:
+/// - Reducing on-chain verification costs by combining multiple proofs into one
+/// - Proving larger block ranges by aggregating individual range proofs
+///
+/// Note: All input range proofs must be in compressed format for aggregation to work.
 #[tokio::main]
 async fn main() -> Result<()> {
     utils::setup_logger();

scripts/prove/bin/multi.rs

@@ -13,7 +13,13 @@ use op_succinct_scripts::HostExecutorArgs;
 use sp1_sdk::{utils, Prover, ProverClient};
 use tracing::debug;
 
-/// Execute the OP Succinct program for multiple blocks.
+/// Generates a compressed range proof for a block range.
+///
+/// This binary generates a compressed SP1 proof that verifies the state transition
+/// for a range of L2 blocks. The compressed proof format is required for aggregation.
+///
+/// The proof verifies that the rollup's state transition function was correctly executed
+/// for all blocks in the specified range.
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = HostExecutorArgs::parse();
@@ -54,7 +60,8 @@ async fn main() -> Result<()> {
 
         let (pk, _) = prover.setup(get_range_elf_embedded());
 
-        // Generate a range proof in compressed mode for aggregation verification.
+        // Generate a compressed range proof. Note that the compressed proof type is required
+        // for aggregation.
         let proof = prover
             .prove(&pk, &sp1_stdin)
             .compressed()