feat(core,host): initial aggregation API

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.2.0](https://github.com/taikoxyz/raiko/compare/v1.1.0...v1.2.0) (2024-09-20)
+
+
+### Features
+
+* **raiko:** make raiko-zk docker image ([#374](https://github.com/taikoxyz/raiko/issues/374)) ([65ff9a4](https://github.com/taikoxyz/raiko/commit/65ff9a4935ac66f0c21785a0b8415313942bda82))
+* **raiko:** traversal to find inclusion block if none inclusion number is sent ([#377](https://github.com/taikoxyz/raiko/issues/377)) ([c2b0db5](https://github.com/taikoxyz/raiko/commit/c2b0db5a61e920840f9de083de8684a8375e51b3))
+* **sgx:** add wallet to provider builder when register instance ([#369](https://github.com/taikoxyz/raiko/issues/369)) ([a250edf](https://github.com/taikoxyz/raiko/commit/a250edf2ca42d5481ba92d97ca6ade5b46bb536c))
+
+
+### Bug Fixes
+
+* **raiko:** refine error return ([#378](https://github.com/taikoxyz/raiko/issues/378)) ([f4f818d](https://github.com/taikoxyz/raiko/commit/f4f818d43a33ba1caf95cb1db4160ba90824eb2d))
+* **script:** output build message and skip `pos` flag ([#367](https://github.com/taikoxyz/raiko/issues/367)) ([2c881dc](https://github.com/taikoxyz/raiko/commit/2c881dc22d5df553bffc24f8bbac6a86e2fd9688))
+
 ## [1.1.0](https://github.com/taikoxyz/raiko/compare/v1.0.0...v1.1.0) (2024-09-13)
 
 

core/src/interfaces.rs

@@ -11,7 +11,7 @@ use raiko_lib::{
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use serde_with::{serde_as, DisplayFromStr};
-use std::{collections::HashMap, path::Path, str::FromStr};
+use std::{collections::HashMap, fmt::Display, path::Path, str::FromStr};
 use utoipa::ToSchema;
 
 #[derive(Debug, thiserror::Error, ToSchema)]
@@ -345,7 +345,7 @@ pub struct ProofRequestOpt {
     pub prover_args: ProverSpecificOpts,
 }
 
-#[derive(Default, Clone, Serialize, Deserialize, Debug, ToSchema, Args)]
+#[derive(Default, Clone, Serialize, Deserialize, Debug, ToSchema, Args, PartialEq, Eq, Hash)]
 pub struct ProverSpecificOpts {
     /// Native prover specific options.
     pub native: Option<Value>,
@@ -442,14 +442,122 @@ impl TryFrom<ProofRequestOpt> for ProofRequest {
     }
 }
 
-#[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Default, Clone, Serialize, Deserialize, Debug, ToSchema)]
+#[serde(default)]
 /// A request for proof aggregation of multiple proofs.
 pub struct AggregationRequest {
-    /// All the proofs to verify
+    /// The block numbers and l1 inclusion block numbers for the blocks to aggregate proofs for.
+    pub block_numbers: Vec<(u64, Option<u64>)>,
+    /// The network to generate the proof for.
+    pub network: Option<String>,
+    /// The L1 network to generate the proof for.
+    pub l1_network: Option<String>,
+    // Graffiti.
+    pub graffiti: Option<String>,
+    /// The protocol instance data.
+    pub prover: Option<String>,
+    /// The proof type.
+    pub proof_type: Option<String>,
+    /// Blob proof type.
+    pub blob_proof_type: Option<String>,
+    #[serde(flatten)]
+    /// Any additional prover params in JSON format.
+    pub prover_args: ProverSpecificOpts,
+}
+
+impl AggregationRequest {
+    /// Merge proof request options into aggregation request options.
+    pub fn merge(&mut self, opts: &ProofRequestOpt) -> RaikoResult<()> {
+        let this = serde_json::to_value(&self)?;
+        let mut opts = serde_json::to_value(opts)?;
+        merge(&mut opts, &this);
+        *self = serde_json::from_value(opts)?;
+        Ok(())
+    }
+}
+
+impl From<AggregationRequest> for Vec<ProofRequestOpt> {
+    fn from(value: AggregationRequest) -> Self {
+        value
+            .block_numbers
+            .iter()
+            .map(
+                |&(block_number, l1_inclusion_block_number)| ProofRequestOpt {
+                    block_number: Some(block_number),
+                    l1_inclusion_block_number,
+                    network: value.network.clone(),
+                    l1_network: value.l1_network.clone(),
+                    graffiti: value.graffiti.clone(),
+                    prover: value.prover.clone(),
+                    proof_type: value.proof_type.clone(),
+                    blob_proof_type: value.blob_proof_type.clone(),
+                    prover_args: value.prover_args.clone(),
+                },
+            )
+            .collect()
+    }
+}
+
+impl From<ProofRequestOpt> for AggregationRequest {
+    fn from(value: ProofRequestOpt) -> Self {
+        let block_numbers = if let Some(block_number) = value.block_number {
+            vec![(block_number, value.l1_inclusion_block_number)]
+        } else {
+            vec![]
+        };
+
+        Self {
+            block_numbers,
+            network: value.network,
+            l1_network: value.l1_network,
+            graffiti: value.graffiti,
+            prover: value.prover,
+            proof_type: value.proof_type,
+            blob_proof_type: value.blob_proof_type,
+            prover_args: value.prover_args,
+        }
+    }
+}
+
+#[derive(Default, Clone, Serialize, Deserialize, Debug, ToSchema, PartialEq, Eq, Hash)]
+#[serde(default)]
+/// A request for proof aggregation of multiple proofs.
+pub struct AggregationOnlyRequest {
+    /// The block numbers and l1 inclusion block numbers for the blocks to aggregate proofs for.
     pub proofs: Vec<Proof>,
     /// The proof type.
-    pub proof_type: ProofType,
-    /// Additional prover params.
-    pub prover_args: HashMap<String, Value>,
+    pub proof_type: Option<String>,
+    #[serde(flatten)]
+    /// Any additional prover params in JSON format.
+    pub prover_args: ProverSpecificOpts,
+}
+
+impl Display for AggregationOnlyRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!(
+            "AggregationOnlyRequest {{ {:?}, {:?} }}",
+            self.proof_type, self.prover_args
+        ))
+    }
+}
+
+impl From<(AggregationRequest, Vec<Proof>)> for AggregationOnlyRequest {
+    fn from((request, proofs): (AggregationRequest, Vec<Proof>)) -> Self {
+        Self {
+            proofs,
+            proof_type: request.proof_type,
+            prover_args: request.prover_args,
+        }
+    }
+}
+
+impl AggregationOnlyRequest {
+    /// Merge proof request options into aggregation request options.
+    pub fn merge(&mut self, opts: &ProofRequestOpt) -> RaikoResult<()> {
+        let this = serde_json::to_value(&self)?;
+        let mut opts = serde_json::to_value(opts)?;
+        merge(&mut opts, &this);
+        *self = serde_json::from_value(opts)?;
+        Ok(())
+    }
 }

core/src/lib.rs

@@ -455,8 +455,8 @@ mod tests {
             .unwrap();
 
         let proof_request = ProofRequest {
-            l1_inclusion_block_number: 0,
             block_number,
+            l1_inclusion_block_number: 0,
             network,
             graffiti: B256::ZERO,
             prover: Address::ZERO,