* init decoupling-post-worker code

filecoin-proofs/src/api/post_util.rs

@@ -7,7 +7,8 @@ use bincode::deserialize;
 use filecoin_hashers::Hasher;
 use log::{info, trace};
 use storage_proofs_core::{
-    cache_key::CacheKey, merkle::MerkleTreeTrait, proof::ProofScheme, sector::SectorId,
+    cache_key::CacheKey, compound_proof::PubVanRsp, merkle::MerkleTreeTrait, proof::ProofScheme,
+    sector::SectorId,
 };
 use storage_proofs_post::fallback::{self, generate_leaf_challenge, FallbackPoSt, SectorProof};
 
@@ -308,3 +309,139 @@ pub(crate) fn get_partitions_for_window_post(
         None
     }
 }
+
+pub fn get_post_vanilla_params<Tree: 'static + MerkleTreeTrait>(
+    post_config: &PoStConfig,
+) -> Result<PubVanRsp> {
+    let rsp = PubVanRsp {
+        challengecount: post_config.challenge_count,
+        sectorcount: post_config.sector_count,
+    };
+
+    Ok(rsp)
+}
+
+pub fn single_partition_vanilla_proofs<Tree: MerkleTreeTrait>(
+    post_config: &PoStConfig,
+    pub_params: &fallback::PublicParams,
+    pub_inputs: &fallback::PublicInputs<<Tree::Hasher as Hasher>::Domain>,
+    partition_count: usize,
+    vanilla_proofs: &[FallbackPoStSectorProof<Tree>],
+    sector_idxs: &[u64],
+) -> Result<Vec<VanillaProof<Tree>>> {
+    info!("single_partition_vanilla_proofs:start");
+    ensure!(
+        post_config.typ == PoStType::Window || post_config.typ == PoStType::Winning,
+        "invalid post config type"
+    );
+
+    let num_sectors_per_chunk = pub_params.sector_count;
+    let num_sectors = pub_inputs.sectors.len();
+
+    ensure!(
+        num_sectors <= partition_count * num_sectors_per_chunk,
+        "cannot prove the provided number of sectors: {} > {} * {}",
+        num_sectors,
+        partition_count,
+        num_sectors_per_chunk,
+    );
+
+    let mut partition_proofs = Vec::new();
+
+    // Note that the partition proofs returned are shaped differently
+    // based on which type of PoSt is being considered.
+    match post_config.typ {
+        PoStType::Window => {
+            for (j, sectors_chunk) in pub_inputs.sectors.chunks(num_sectors_per_chunk).enumerate() {
+                trace!("processing partition {}", j);
+
+                let mut sector_proofs = Vec::with_capacity(num_sectors_per_chunk);
+
+                for pub_sector in sectors_chunk.iter() {
+                    let cur_proof = vanilla_proofs
+                        .iter()
+                        .find(|&proof| proof.sector_id == pub_sector.id)
+                        .expect("failed to locate sector proof");
+
+                    // Note: Window post requires all inclusion proofs (based on the challenge
+                    // count per sector) per sector proof.
+                    sector_proofs.extend(cur_proof.vanilla_proof.sectors.clone());
+                }
+
+                // If there were less than the required number of sectors provided, we duplicate the last one
+                // to pad the proof out, such that it works in the circuit part.
+                while sector_proofs.len() < num_sectors_per_chunk {
+                    sector_proofs.push(sector_proofs[sector_proofs.len() - 1].clone());
+                }
+
+                partition_proofs.push(fallback::Proof::<<Tree as MerkleTreeTrait>::Proof> {
+                    sectors: sector_proofs,
+                });
+            }
+        }
+        PoStType::Winning => {
+            for (j, sectors_chunk) in vanilla_proofs.chunks(num_sectors_per_chunk).enumerate() {
+                trace!("processing partition {}", j);
+
+                // Sanity check incoming structure
+                ensure!(
+                    sectors_chunk.len() == 1,
+                    "Invalid sector chunk for Winning PoSt"
+                );
+                ensure!(
+                    sectors_chunk[0].vanilla_proof.sectors.len() == 1,
+                    "Invalid sector count for Winning PoSt chunk"
+                );
+
+                // Winning post sector_count is winning post challenges per sector
+                ensure!(
+                    post_config.sector_count == sectors_chunk[j].vanilla_proof.sectors.len(),
+                    "invalid number of sector proofs for Winning PoSt"
+                );
+
+                let mut sector_proofs = Vec::with_capacity(post_config.challenge_count);
+                let cur_sector_proof = &sectors_chunk[0].vanilla_proof.sectors[0];
+
+                // Unroll inclusions proofs from the single provided sector_proof (per partition)
+                // into individual sector proofs, required for winning post.
+                for cur_inclusion_proof in cur_sector_proof.inclusion_proofs() {
+                    sector_proofs.push(SectorProof {
+                        inclusion_proofs: vec![cur_inclusion_proof.clone()],
+                        comm_c: cur_sector_proof.comm_c,
+                        comm_r_last: cur_sector_proof.comm_r_last,
+                    });
+                }
+
+                // If there were less than the required number of sectors provided, we duplicate the last one
+                // to pad the proof out, such that it works in the circuit part.
+                while sector_proofs.len() < num_sectors_per_chunk {
+                    sector_proofs.push(sector_proofs[sector_proofs.len() - 1].clone());
+                }
+
+                // Winning post Challenge count is the total winning post challenges
+                ensure!(
+                    sector_proofs.len() == post_config.challenge_count,
+                    "invalid number of partition proofs based on Winning PoSt challenges"
+                );
+
+                partition_proofs.push(fallback::Proof::<<Tree as MerkleTreeTrait>::Proof> {
+                    sectors: sector_proofs,
+                });
+            }
+        }
+    }
+
+    info!("single_partition_vanilla_proofs:finish");
+
+    ensure!(
+        FallbackPoSt::<Tree>::verify_single_partitions(
+            pub_params,
+            pub_inputs,
+            &partition_proofs,
+            sector_idxs
+        )?,
+        "partitioned vanilla proofs failed to verify"
+    );
+
+    Ok(partition_proofs)
+}

filecoin-proofs/src/api/window_post.rs

@@ -14,7 +14,10 @@ use storage_proofs_post::fallback::{
 };
 
 use crate::{
-    api::{as_safe_commitment, get_partitions_for_window_post, partition_vanilla_proofs},
+    api::{
+        as_safe_commitment, get_partitions_for_window_post, partition_vanilla_proofs,
+        single_partition_vanilla_proofs,
+    },
     caches::{get_post_params, get_post_verifying_key},
     parameters::window_post_setup_params,
     types::{
@@ -242,3 +245,73 @@ pub fn verify_window_post<Tree: 'static + MerkleTreeTrait>(
 
     Ok(true)
 }
+
+/// Generates a Window proof-of-spacetime with provided vanilla proofs of a single partition
+pub fn generate_single_window_post_with_vanilla<Tree: 'static + MerkleTreeTrait>(
+    post_config: &PoStConfig,
+    randomness: &ChallengeSeed,
+    prover_id: ProverId,
+    vanilla_proofs: Vec<FallbackPoStSectorProof<Tree>>,
+    sector_idxs: &[u64],
+) -> Result<SnarkProof> {
+    info!("generate_single_window_post_with_vanilla:start");
+    ensure!(
+        post_config.typ == PoStType::Window,
+        "invalid post config type"
+    );
+
+    let randomness_safe: <Tree::Hasher as Hasher>::Domain =
+        as_safe_commitment(randomness, "randomness")?;
+    let prover_id_safe: <Tree::Hasher as Hasher>::Domain =
+        as_safe_commitment(&prover_id, "prover_id")?;
+
+    let vanilla_params = window_post_setup_params(&post_config);
+    let partitions = get_partitions_for_window_post(vanilla_proofs.len(), &post_config);
+
+    let setup_params = compound_proof::SetupParams {
+        vanilla_params,
+        partitions,
+        priority: post_config.priority,
+    };
+
+    let partitions = partitions.unwrap_or(1);
+
+    let pub_params: compound_proof::PublicParams<'_, FallbackPoSt<'_, Tree>> =
+        FallbackPoStCompound::setup(&setup_params)?;
+    let groth_params = get_post_params::<Tree>(&post_config)?;
+
+    let mut pub_sectors = Vec::with_capacity(vanilla_proofs.len());
+    for vanilla_proof in &vanilla_proofs {
+        pub_sectors.push(PublicSector {
+            id: vanilla_proof.sector_id,
+            comm_r: vanilla_proof.comm_r,
+        });
+    }
+
+    let pub_inputs = fallback::PublicInputs {
+        randomness: randomness_safe,
+        prover_id: prover_id_safe,
+        sectors: pub_sectors,
+        k: None,
+    };
+
+    let partitioned_proofs = single_partition_vanilla_proofs(
+        &post_config,
+        &pub_params.vanilla_params,
+        &pub_inputs,
+        partitions,
+        &vanilla_proofs,
+        sector_idxs,
+    )?;
+
+    let proof = FallbackPoStCompound::prove_with_vanilla(
+        &pub_params,
+        &pub_inputs,
+        partitioned_proofs,
+        &groth_params,
+    )?;
+
+    info!("generate_single_window_post_with_vanilla:finish");
+
+    proof.to_vec()
+}