Use scan to always keep the previous proof for recursive proving

node/src/lib.rs

@@ -1010,6 +1010,8 @@ where
 
     let oracle_stream = create_oracle_stream(oracle, last_parent_height, Some(signer.clone()))?;
 
+    let latest_proof = node.get_latest_proof().await?;
+
     oracle_stream
         .block_height_parent(last_parent_height, last_parent_hash)
         .and_then(|block| {
@@ -1019,46 +1021,61 @@ where
         .prove(move |block, witness| {
             void_toolkit::proof::host::prove(&block, witness, &state_elf_code)
         })
-        .and_then(|zk_state_proof| {
-            let node = node.clone();
+        .scan_owned(latest_proof, |mut latest_proof, zk_state_proof| {
             let recursive_elf_code = recursive_elf_code.clone();
             async move {
-                let Height {
-                    block_height,
-                    data: zk_state_proof,
-                } = zk_state_proof;
-                let zk_state_proof_receipt = serde_json::from_slice(&zk_state_proof)?;
-                let latest_proof = node.get_latest_proof().await?;
-                let recursive = match latest_proof {
-                    Some(recursive_receipt) => {
-                        let recursive_receipt =
-                            serde_json::from_slice(&recursive_receipt.data.proof.data)?;
-                        RecursiveArgs::Step(Box::new(recursive_receipt))
+                let result =
+                    prove_recursive(zk_state_proof, latest_proof.clone(), recursive_elf_code).await;
+                let zk_proof = match result {
+                    Ok(proof) => proof,
+                    Err(e) => {
+                        return (latest_proof, Err(e));
                     }
-                    None => RecursiveArgs::Init(Init {
-                        this_image_id: risc0_zkvm::compute_image_id(&recursive_elf_code)?.into(),
-                    }),
-                };
-                let input = void_toolkit::proof::host::recursive::Input {
-                    recursive,
-                    state_receipts: vec![zk_state_proof_receipt],
                 };
-                let result = tokio::task::spawn_blocking(move || {
-                    void_toolkit::proof::host::recursive::proof(input, &recursive_elf_code)
-                })
-                .await?;
-                Ok(Height::new(block_height, result?))
+                latest_proof = Some(zk_proof.clone());
+                (latest_proof, Ok(zk_proof))
             }
         })
         .try_for_each(|zk_proof| async {
-            let zk_proof = Height::new(zk_proof.block_height, ZkProof { proof: zk_proof });
             node.replicator.update(zk_proof).await?;
             Ok(())
         })
         .await?;
     Ok(())
 }
 
+async fn prove_recursive(
+    zk_state_proof: Height<Vec<u8>>,
+    latest_proof: Option<Height<ZkProof>>,
+    recursive_elf_code: Arc<Vec<u8>>,
+) -> Result<Height<ZkProof>, anyhow::Error> {
+    let Height {
+        block_height,
+        data: zk_state_proof,
+    } = zk_state_proof;
+    let zk_state_proof_receipt = serde_json::from_slice(&zk_state_proof)?;
+    let recursive = match latest_proof.clone() {
+        Some(recursive_receipt) => {
+            let recursive_receipt = serde_json::from_slice(&recursive_receipt.data.proof.data)?;
+            RecursiveArgs::Step(Box::new(recursive_receipt))
+        }
+        None => RecursiveArgs::Init(Init {
+            this_image_id: risc0_zkvm::compute_image_id(&recursive_elf_code)?.into(),
+        }),
+    };
+    let input = void_toolkit::proof::host::recursive::Input {
+        recursive,
+        state_receipts: vec![zk_state_proof_receipt],
+    };
+    let result = tokio::task::spawn_blocking(move || {
+        void_toolkit::proof::host::recursive::proof::<[u8; 32]>(input, &recursive_elf_code)
+    })
+    .await?;
+    let zk_proof = Height::new(block_height, result?);
+    let zk_proof = Height::new(zk_proof.block_height, ZkProof { proof: zk_proof });
+    Ok(zk_proof)
+}
+
 fn create_oracle_stream(
     oracle: OracleMode,
     last_parent_height: Option<u64>,