agg window post api

extern/filecoin-ffi/generated/generated.go

@@ -13,7 +13,6 @@ package generated
 import "C"
 import (
 	"runtime"
-	"fmt"
 	"unsafe"
 )
 
@@ -405,6 +404,25 @@ func FilGenerateWindowPost(randomness Fil32ByteArray, replicasPtr []FilPrivateRe
 	return __v
 }
 
+// FilGenerateWindowPost function as declared in filecoin-ffi/filcrypto.h:498
+func FilAggregateWindowPoStProofs(registeredAggregation FilRegisteredAggregationProof, randomnessesPtr []Fil32ByteArray, randomnessesLen uint, proofsPtr []FilPoStProof, proofsLen uint) *FilAggregateProof {
+	cregisteredAggregation, cregisteredAggregationAllocMap := (C.fil_RegisteredAggregationProof)(registeredAggregation), cgoAllocsUnknown
+	crandomnessesPtr, crandomnessesPtrAllocMap := unpackArgSFil32ByteArray(randomnessesPtr)
+	crandomnessesLen, crandomnessesLenAllocMap := (C.size_t)(randomnessesLen), cgoAllocsUnknown
+	cproofsPtr, cproofsPtrAllocMap := unpackArgSFilPoStProof(proofsPtr)
+	cproofsLen, cproofsLenAllocMap := (C.size_t)(proofsLen), cgoAllocsUnknown
+	__ret := C.fil_aggregate_window_post_proofs(cregisteredAggregation, crandomnessesPtr, crandomnessesLen, cproofsPtr, cproofsLen)
+	runtime.KeepAlive(cproofsLenAllocMap)
+	packSFilPoStProof(proofsPtr, cproofsPtr)
+	runtime.KeepAlive(cproofsPtrAllocMap)
+	runtime.KeepAlive(crandomnessesLenAllocMap)
+	packSFil32ByteArray(randomnessesPtr, crandomnessesPtr)
+	runtime.KeepAlive(crandomnessesPtrAllocMap)
+	runtime.KeepAlive(cregisteredAggregationAllocMap)
+	__v := NewFilAggregateProofRef(unsafe.Pointer(__ret))
+	return __v
+}
+
 // FilGenerateWindowPostWithVanilla function as declared in filecoin-ffi/filcrypto.h:507
 func FilGenerateWindowPostWithVanilla(registeredProof FilRegisteredPoStProof, randomness Fil32ByteArray, proverId Fil32ByteArray, vanillaProofsPtr []FilVanillaProof, vanillaProofsLen uint) *FilGenerateWindowPoStResponse {
 	cregisteredProof, cregisteredProofAllocMap := (C.fil_RegisteredPoStProof)(registeredProof), cgoAllocsUnknown
@@ -728,7 +746,6 @@ func FilSealCommitPhase2(sealCommitPhase1OutputPtr []byte, sealCommitPhase1Outpu
 func FilSealPreCommitPhase1(registeredProof FilRegisteredSealProof, cacheDirPath string, stagedSectorPath string, sealedSectorPath string, sectorId uint64, proverId Fil32ByteArray, ticket Fil32ByteArray, piecesPtr []FilPublicPieceInfo, piecesLen uint) *FilSealPreCommitPhase1Response {
 	cregisteredProof, cregisteredProofAllocMap := (C.fil_RegisteredSealProof)(registeredProof), cgoAllocsUnknown
 	cacheDirPath = safeString(cacheDirPath)
-	// fmt.Print("hi generated, from dongzh\n")
 	ccacheDirPath, ccacheDirPathAllocMap := unpackPCharString(cacheDirPath)
 	stagedSectorPath = safeString(stagedSectorPath)
 	cstagedSectorPath, cstagedSectorPathAllocMap := unpackPCharString(stagedSectorPath)
@@ -870,7 +887,7 @@ func FilVerifySeal(registeredProof FilRegisteredSealProof, commR Fil32ByteArray,
 }
 
 // FilVerifyWindowPost function as declared in filecoin-ffi/filcrypto.h:817
-func FilVerifyWindowPost(randomness Fil32ByteArray, replicasPtr []FilPublicReplicaInfo, replicasLen uint, proofsPtr []FilPoStProof, proofsLen uint, proverId Fil32ByteArray) *FilVerifyWindowPoStResponse {
+func FilVerifyWindowPoSt(randomness Fil32ByteArray, replicasPtr []FilPublicReplicaInfo, replicasLen uint, proofsPtr []FilPoStProof, proofsLen uint, proverId Fil32ByteArray) *FilVerifyWindowPoStResponse {
 	crandomness, crandomnessAllocMap := randomness.PassValue()
 	creplicasPtr, creplicasPtrAllocMap := unpackArgSFilPublicReplicaInfo(replicasPtr)
 	creplicasLen, creplicasLenAllocMap := (C.size_t)(replicasLen), cgoAllocsUnknown
@@ -890,6 +907,34 @@ func FilVerifyWindowPost(randomness Fil32ByteArray, replicasPtr []FilPublicRepli
 	return __v
 }
 
+func FilVerifyAggregateWindowPoStProofs(registeredProof FilRegisteredPoStProof, registeredAggregation FilRegisteredAggregationProof, proverId Fil32ByteArray, proofPtr []byte, proofLen uint, randomnessesPtr []Fil32ByteArray, randomnessesLen uint, replicasPtr []FilPublicReplicaInfo, arrPtr []uint64, arrLen uint) *FilVerifyAggregateSealProofResponse {
+	cregisteredProof, cregisteredProofAllocMap := (C.fil_RegisteredPoStProof)(registeredProof), cgoAllocsUnknown
+	cregisteredAggregation, cregisteredAggregationAllocMap := (C.fil_RegisteredAggregationProof)(registeredAggregation), cgoAllocsUnknown
+	cproverId, cproverIdAllocMap := proverId.PassValue()
+	cproofPtr, cproofPtrAllocMap := copyPUint8TBytes((*sliceHeader)(unsafe.Pointer(&proofPtr)))
+	cproofLen, cproofLenAllocMap := (C.size_t)(proofLen), cgoAllocsUnknown
+	crandomnessesPtr, crandomnessesPtrAllocMap := unpackArgSFil32ByteArray(randomnessesPtr)
+	crandomnessesLen, crandomnessesLenAllocMap := (C.size_t)(randomnessesLen), cgoAllocsUnknown
+	creplicasPtr, creplicasPtrAllocMap := unpackArgSFilPublicReplicaInfo(replicasPtr)
+	carrPtr, carrPtrAlocMap := copyPUint64TBytes((*sliceHeader)(unsafe.Pointer(&arrPtr)))
+	carrLen, carrLenAlocMap := (C.size_t)(arrLen), cgoAllocsUnknown
+	__ret := C.fil_verify_aggregate_window_post_proofs(cregisteredProof, cregisteredAggregation, cproverId, cproofPtr, cproofLen, crandomnessesPtr, crandomnessesLen, creplicasPtr, carrPtr, carrLen)
+	runtime.KeepAlive(carrLenAlocMap)
+	runtime.KeepAlive(carrPtrAlocMap)
+	packSFilPublicReplicaInfo(replicasPtr, creplicasPtr)
+	runtime.KeepAlive(creplicasPtrAllocMap)
+	runtime.KeepAlive(crandomnessesLenAllocMap)
+	packSFil32ByteArray(randomnessesPtr, crandomnessesPtr)
+	runtime.KeepAlive(crandomnessesPtrAllocMap)
+	runtime.KeepAlive(cproofLenAllocMap)
+	runtime.KeepAlive(cproofPtrAllocMap)
+	runtime.KeepAlive(cproverIdAllocMap)
+	runtime.KeepAlive(cregisteredAggregationAllocMap)
+	runtime.KeepAlive(cregisteredProofAllocMap)
+	__v := NewFilVerifyAggregateSealProofResponseRef(unsafe.Pointer(__ret))
+	return __v
+}
+
 // FilVerifyWinningPost function as declared in filecoin-ffi/filcrypto.h:827
 func FilVerifyWinningPost(randomness Fil32ByteArray, replicasPtr []FilPublicReplicaInfo, replicasLen uint, proofsPtr []FilPoStProof, proofsLen uint, proverId Fil32ByteArray) *FilVerifyWinningPoStResponse {
 	crandomness, crandomnessAllocMap := randomness.PassValue()

extern/filecoin-ffi/proofs.go

@@ -170,7 +170,7 @@ func VerifyWindowPoSt(info proof5.WindowPoStVerifyInfo) (bool, error) {
 		return false, err
 	}
 
-	resp := generated.FilVerifyWindowPost(
+		resp := generated.FilVerifyWindowPoSt(
 		to32ByteArray(info.Randomness),
 		filPublicReplicaInfos, filPublicReplicaInfosLen,
 		filPoStProofs, filPoStProofsLen,
@@ -187,6 +187,61 @@ func VerifyWindowPoSt(info proof5.WindowPoStVerifyInfo) (bool, error) {
 	return resp.IsValid, nil
 }
 
+func VerifyAggregateWindowPostProofs(aggregateInfo AggregateWindowPostInfos)(bool, error) {
+	if len(aggregateInfo.ChallengedSectors) == 0 {
+		return false, xerrors.New("no seal verify infos")
+	}
+
+	filPublicReplicaInfos, _, err := toFilPublicReplicaInfos(aggregateInfo.ChallengedSectors, "window")
+	if err != nil {
+		return false, errors.Wrap(err, "failed to create public replica info array for FFI")
+	}
+
+	spt := aggregateInfo.PoStType // todo assuming this needs to be the same for all sectors, potentially makes sense to put in AggregateSealVerifyProofAndInfos
+
+	sp, err := toFilRegisteredPoStProof(spt)
+	if err != nil {
+		return false, err
+	}
+
+	proverID, err := toProverID(aggregateInfo.Miner)
+	if err != nil {
+		return false, err
+	}
+
+	randomnesses := make([]generated.Fil32ByteArray, len(aggregateInfo.Randomnesses))
+	for i, randomness := range aggregateInfo.Randomnesses {
+		// randomness[31] &= 0x3f
+		randomnesses[i] = to32ByteArray(randomness)
+	}
+
+	rap, err := toFilRegisteredAggregationProof(aggregateInfo.AggregateType)
+	if err != nil {
+		return false, err
+	}
+
+	resp := generated.FilVerifyAggregateWindowPoStProofs(
+			sp, 
+			rap, 
+			proverID, 
+			aggregateInfo.AggregationProof, 
+			uint(len(aggregateInfo.AggregationProof)), 
+			randomnesses,
+			uint(len(randomnesses)),
+			filPublicReplicaInfos, 
+			aggregateInfo.Arr, 
+			uint(len(aggregateInfo.Arr)))
+	resp.Deref()
+
+	defer generated.FilDestroyVerifyAggregateSealResponse(resp)
+
+	if resp.StatusCode != generated.FCPResponseStatusFCPNoError {
+		return false, errors.New(generated.RawString(resp.ErrorMsg).Copy())
+	}
+
+	return resp.IsValid, nil
+}
+
 // GeneratePieceCommitment produces a piece commitment for the provided data
 // stored at a given path.
 func GeneratePieceCID(proofType abi.RegisteredSealProof, piecePath string, pieceSize abi.UnpaddedPieceSize) (cid.Cid, error) {
@@ -701,6 +756,36 @@ func GenerateWindowPoSt(
 
 	return proofs, faultySectors, nil
 }
+// GenerateWindowPoSt
+func AggregateWindowPoStProofs(aggregateInfo AggregateWindowPostInfos) ([]byte, error) {
+	rap, err := toFilRegisteredAggregationProof(aggregateInfo.AggregateType)
+	if err != nil {
+		return nil, err
+	}
+
+	randomnesses := make([]generated.Fil32ByteArray, len(aggregateInfo.Randomnesses))
+	for i, randomness := range aggregateInfo.Randomnesses {
+		// randomness[31] &= 0x3f
+		randomnesses[i] = to32ByteArray(randomness)
+	}
+
+	filPoStProofs, filPoStProofsLen, free, err := toFilPoStProofs(aggregateInfo.Proofs)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create PoSt proofs array for FFI")
+	}
+	defer free()
+
+	resp := generated.FilAggregateWindowPoStProofs(rap, randomnesses, uint(len(randomnesses)), filPoStProofs, filPoStProofsLen)
+	resp.Deref()
+
+	defer generated.FilDestroyAggregateProof(resp)
+
+	if resp.StatusCode != generated.FCPResponseStatusFCPNoError {
+		return nil, errors.New(generated.RawString(resp.ErrorMsg).Copy())
+	}
+
+	return copyBytes(resp.ProofPtr, resp.ProofLen), nil
+}
 
 // GetGPUDevices produces a slice of strings, each representing the name of a
 // detected GPU device.

extern/filecoin-ffi/rust/src/proofs/api.rs

@@ -1240,6 +1240,124 @@ pub unsafe extern "C" fn fil_verify_window_post(
     })
 }
 
+
+#[no_mangle]
+pub unsafe extern "C" fn fil_aggregate_window_post_proofs(
+    registered_aggregation: fil_RegisteredAggregationProof,
+    randomnesses_ptr: *const fil_32ByteArray,
+    randomnesses_len: libc::size_t,
+    proofs_ptr: *const fil_PoStProof,
+    proofs_len: libc::size_t,
+    total_sector_count: libc::size_t,
+) -> *mut fil_AggregateProof {
+    catch_panic_response(|| {
+        init_log();
+        info!("aggregate_window_post_proofs: start");
+
+        // let responses: &[fil_SealCommitPhase2Response] =
+        //     std::slice::from_raw_parts(seal_commit_responses_ptr, seal_commit_responses_len);
+        // let outputs: Vec<SealCommitPhase2Output> = responses.iter().map(|x| x.into()).collect();
+
+        let raw_randomnesses: &[fil_32ByteArray] = std::slice::from_raw_parts(randomnesses_ptr, randomnesses_len);
+        let randomnesses: Vec<[u8; 32]> = raw_randomnesses.iter().map(|x| x.inner).collect();
+
+        let proofs: Vec<(RegisteredPoStProof, &[u8])> = from_raw_parts(proofs_ptr, proofs_len)
+            .iter()
+            .map(|x| (x.registered_proof.into(), from_raw_parts(x.proof_ptr, x.proof_len)))
+            .collect();
+
+        let mut response = fil_AggregateProof::default();
+
+        let result = filecoin_proofs_api::post::aggregate_window_post_proofs(
+            registered_aggregation.into(),
+            &randomnesses,
+            &proofs,
+            total_sector_count,
+        );
+
+        match result {
+            Ok(output) => {
+                response.status_code = FCPResponseStatus::FCPNoError;
+                response.proof_ptr = output.as_ptr();
+                response.proof_len = output.len();
+
+                mem::forget(output);
+            }
+            Err(err) => {
+                response.status_code = FCPResponseStatus::FCPUnclassifiedError;
+                response.error_msg = rust_str_to_c_str(format!("{:?}", err));
+            }
+        }
+
+        info!("aggregate_window_post_proofs: finish");
+
+        raw_ptr(response)
+    })
+}
+
+/// Verifies the output of an aggregated window post.
+///
+#[no_mangle]
+pub unsafe extern "C" fn fil_verify_aggregate_window_post_proofs(
+    registered_proof: fil_RegisteredPoStProof,
+    registered_aggregation: fil_RegisteredAggregationProof,
+    prover_id: fil_32ByteArray,
+    proof_ptr: *const u8,
+    proof_len: libc::size_t,
+    randomnesses_ptr: *mut fil_32ByteArray,
+    randomnesses_len: libc::size_t,
+    replicas_ptr: *const fil_PublicReplicaInfo,
+    arr_ptr: *const u64,
+    arr_len: libc::size_t,
+) -> *mut fil_VerifyAggregateSealProofResponse {
+    catch_panic_response(|| {
+        init_log();
+
+        info!("verify_aggregate_seal_proof: start");
+
+        let mut response = fil_VerifyAggregateSealProofResponse::default();
+
+        let convert = super::helpers::to_public_replica_infos_map(replicas_ptr, arr_ptr, arr_len);
+
+        let result = convert.and_then(|replicas| {
+            let raw_randomnesses: &[fil_32ByteArray] = std::slice::from_raw_parts(randomnesses_ptr, randomnesses_len);
+            let randomnesses: Vec<[u8; 32]> = raw_randomnesses.iter().map(|x| x.inner).collect();
+
+            let proof_bytes: Vec<u8> =
+                std::slice::from_raw_parts(proof_ptr, proof_len).to_vec();
+
+            filecoin_proofs_api::post::verify_aggregate_window_post_proofs(
+                registered_proof.into(),
+                registered_aggregation.into(),
+                prover_id.inner,
+                proof_bytes,
+                &randomnesses,
+                replicas.as_ref(),
+            )
+        });
+
+        match result {
+            Ok(true) => {
+                response.status_code = FCPResponseStatus::FCPNoError;
+                response.is_valid = true;
+            }
+            Ok(false) => {
+                response.status_code = FCPResponseStatus::FCPNoError;
+                response.is_valid = false;
+            }
+            Err(err) => {
+                response.status_code = FCPResponseStatus::FCPUnclassifiedError;
+                response.error_msg = rust_str_to_c_str(format!("{:?}", err));
+                response.is_valid = false;
+            }
+        }
+
+        info!("verify_aggregate_window_post_proof: finish");
+
+        raw_ptr(response)
+    })
+}
+
 /// Returns the merkle root for a piece after piece padding and alignment.
 /// The caller is responsible for closing the passed in file descriptor.
 #[no_mangle]

extern/filecoin-ffi/rust/src/proofs/helpers.rs

@@ -54,6 +54,54 @@ pub unsafe fn to_public_replica_info_map(
     Ok(map)
 }
 
+#[allow(clippy::type_complexity)]
+pub unsafe fn to_public_replica_infos_map(
+    replicas_ptr: *const fil_PublicReplicaInfo,
+    arr_ptr: *const u64,
+    arr_len: libc::size_t,
+) -> Result<Vec<BTreeMap<SectorId, PublicReplicaInfo>>> {
+
+    ensure!(!replicas_ptr.is_null(), "replicas_ptr must not be null");
+    ensure!(!arr_ptr.is_null(), "arr_ptr must not be null");
+
+    let mut replicas = Vec::new();
+    let mut replicas_len:u64 = 0u64;
+    let mut public_replica_infos = Vec::new();
+
+    let arr = std::slice::from_raw_parts(arr_ptr, arr_len);
+
+    for replica_len in arr.iter() {
+        replicas_len += replica_len;
+    }
+
+    for ffi_info in from_raw_parts(replicas_ptr, replicas_len as usize) {
+        replicas.push(PublicReplicaInfoTmp {
+            sector_id: ffi_info.sector_id,
+            registered_proof: ffi_info.registered_proof,
+            comm_r: ffi_info.comm_r,
+        });
+    }
+
+    let mut start = 0;
+    let mut end = 0;
+    for replica_len in arr.iter() {
+        let mut pub_replica_info: BTreeMap<SectorId, PublicReplicaInfo> = BTreeMap::new();
+        end += replica_len;
+        for index in start..end {
+            let PublicReplicaInfoTmp {
+                registered_proof,
+                comm_r,
+                sector_id,
+            } = replicas[index as usize];
+            pub_replica_info.insert(SectorId::from(sector_id), PublicReplicaInfo::new(registered_proof.into(), comm_r));
+        }
+        public_replica_infos.push(pub_replica_info);
+        start += replica_len;
+    }
+
+    Ok(public_replica_infos)
+}
+
 #[derive(Debug, Clone)]
 struct PrivateReplicaInfoTmp {
     pub registered_proof: fil_RegisteredPoStProof,

extern/filecoin-ffi/types.go

@@ -8,8 +8,20 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
 	"github.com/ipfs/go-cid"
+	proof5 "github.com/filecoin-project/specs-actors/v5/actors/runtime/proof"
 )
 
+type AggregateWindowPostInfos struct{
+	PoStType abi.RegisteredPoStProof
+	AggregateType abi.RegisteredAggregationProof
+	Miner abi.ActorID
+	AggregationProof []byte
+	ChallengedSectors []proof5.SectorInfo
+	Proofs []proof5.PoStProof
+	Arr []uint64
+	Randomnesses []abi.SealRandomness
+}
+
 // BLS
 
 // SignatureBytes is the length of a BLS signature

extern/rust-fil-proofs/fil-proofs-tooling/src/bin/benchy/aggregate_proof.rs

@@ -7,6 +7,7 @@ use bincode::deserialize;
 use std::str::FromStr;
 use filecoin_hashers::{Domain, HashFunction, Hasher, PoseidonArity};
 
+use bellperson::bls::Fr;
 use fil_proofs_tooling::measure;
 use fil_proofs_tooling::shared::{PROVER_ID, RANDOMNESS};
 use filecoin_proofs::constants::{
@@ -19,6 +20,7 @@ use storage_proofs_core::api_version::ApiVersion;
 use filecoin_proofs::{
 	generate_window_post, with_shape, PoStType, PrivateReplicaInfo, commitment_from_fr,
 	PublicReplicaInfo, aggregate_window_post_proofs, verify_aggregate_window_post_proofs,
+    get_window_post_inputs,
 };
 use storage_proofs_core::merkle::MerkleTreeTrait;
 use storage_proofs_core::sector::SectorId;
@@ -52,39 +54,42 @@ fn run_agg_proofs<Tree: 'static + MerkleTreeTrait>(
 
     let start_time = Instant::now();
 	for index in 0..num_agg {
-		let sector_id = index % 2048;
-		let cache_dir = root_dir.join(format!("cache-{}",sector_id));
-		let (comm_d, comm_r_last) = {
-	        let p_aux_path = cache_dir.join(CacheKey::PAux.to_string());
-	        let p_aux_bytes = fs::read(&p_aux_path)?;
 
-	        deserialize(&p_aux_bytes)
-	    }?;
-	    let commr: <Tree::Hasher as Hasher>::Domain =
-            <Tree::Hasher as Hasher>::Function::hash2(&comm_d, &comm_r_last);
-        let comm_r = commitment_from_fr(commr.into());
+        let mut pub_replica_info: BTreeMap<SectorId, PublicReplicaInfo> = BTreeMap::new();
+        let mut priv_replica_info: BTreeMap<SectorId, PrivateReplicaInfo<Tree>> = BTreeMap::new();
 
-        let sector_id = SectorId::from(sector_id);
-        let sealed_file_path = cache_dir.join("sealed-file");
+        for k in 0..2{
+            let sector_id = (index * 2 + k) % 2048;
+            let cache_dir = root_dir.join(format!("cache-{}",sector_id));
+            let (comm_d, comm_r_last) = {
+                let p_aux_path = cache_dir.join(CacheKey::PAux.to_string());
+                let p_aux_bytes = fs::read(&p_aux_path)?;
 
-        let pub_replica = PublicReplicaInfo::new(comm_r).expect("failed to create public replica info");
+                deserialize(&p_aux_bytes)
+            }?;
+            let commr: <Tree::Hasher as Hasher>::Domain =
+                <Tree::Hasher as Hasher>::Function::hash2(&comm_d, &comm_r_last);
+            let comm_r = commitment_from_fr(commr.into());
 
-        let priv_replica = PrivateReplicaInfo::<Tree>::new(sealed_file_path, comm_r, cache_dir.clone())
-            .expect("failed to create private replica info");
+            let sector_id = SectorId::from(sector_id);
+            let sealed_file_path = cache_dir.join("sealed-file");
 
-        let mut pub_replica_info: BTreeMap<SectorId, PublicReplicaInfo> = BTreeMap::new();
-        let mut priv_replica_info: BTreeMap<SectorId, PrivateReplicaInfo<Tree>> = BTreeMap::new();
+            let pub_replica = PublicReplicaInfo::new(comm_r).expect("failed to create public replica info");
 
-        pub_replica_info.insert(sector_id, pub_replica);
-        priv_replica_info.insert(sector_id, priv_replica);
+            let priv_replica = PrivateReplicaInfo::<Tree>::new(sealed_file_path, comm_r, cache_dir.clone())
+                .expect("failed to create private replica info");
+
+            pub_replica_info.insert(sector_id, pub_replica);
+            priv_replica_info.insert(sector_id, priv_replica);
+        }
 
         pub_replica_infos.push(pub_replica_info);
 
-        if index == 0 {
-            randomnesses.push(FAKE_RANDOMNESS);
-        } else {
-            randomnesses.push(RANDOMNESS);
-        }
+        // if index == 0 {
+        //     randomnesses.push(FAKE_RANDOMNESS);
+        // } else {
+        randomnesses.push(RANDOMNESS);
+        // }
         
         let gen_window_post_measurement = measure(|| {
             generate_window_post::<Tree>(&post_config, &RANDOMNESS, &priv_replica_info, PROVER_ID)
@@ -97,8 +102,21 @@ fn run_agg_proofs<Tree: 'static + MerkleTreeTrait>(
 	}
 	let generate_window_post_time = start_time.elapsed().as_millis();
 
+    use rayon::prelude::*;
+    let commit_inputs: Vec<Vec<Fr>> = pub_replica_infos
+        .par_iter()
+        .zip(randomnesses.par_iter())
+        .map(|(replica, randomness)| get_window_post_inputs::<Tree>(&post_config, replica, randomness, PROVER_ID))
+        .try_reduce(Vec::new, |mut acc, current| {
+                acc.extend(current);
+                Ok(acc)
+            })?;
+    for commit_input in commit_inputs.iter(){
+        println!("\n commit inputs : {:?}", commit_input);
+    }
+
 	let start_time = Instant::now();
-    let aggregate_proof = &aggregate_window_post_proofs::<Tree>(&post_config, randomnesses.as_slice(), proofs.as_slice(), 1)?;
+    let aggregate_proof = &aggregate_window_post_proofs::<Tree>(&post_config, randomnesses.as_slice(), proofs.as_slice(), 2)?;
     let aggregate_window_post_proofs_cold_time = start_time.elapsed().as_millis();
 
     let start_time = Instant::now();
@@ -106,7 +124,7 @@ fn run_agg_proofs<Tree: 'static + MerkleTreeTrait>(
     let verify_aggregate_proofs_cold_time = start_time.elapsed().as_millis();
 
     let start_time = Instant::now();
-    let aggregate_proof = &aggregate_window_post_proofs::<Tree>(&post_config, randomnesses.as_slice(), proofs.as_slice(), 1)?;
+    let aggregate_proof = &aggregate_window_post_proofs::<Tree>(&post_config, randomnesses.as_slice(), proofs.as_slice(), 2)?;
     let aggregate_window_post_proofs_hot_time = start_time.elapsed().as_millis();
 
     let start_time = Instant::now();

extern/rust-fil-proofs/fil-proofs-tooling/src/bin/benchy/window_post.rs

@@ -5,6 +5,7 @@ use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::time::Instant;
 
+use bellperson::bls::Fr;
 use anyhow::{ensure, Context};
 use bincode::{deserialize, serialize};
 use fil_proofs_tooling::measure::FuncMeasurement;
@@ -23,6 +24,7 @@ use filecoin_proofs::{
     seal_commit_phase2, seal_pre_commit_phase1, seal_pre_commit_phase2, validate_cache_for_commit,
     validate_cache_for_precommit_phase2, verify_window_post, with_shape, PoStType,
     PrivateReplicaInfo, PublicReplicaInfo, aggregate_window_post_proofs, verify_aggregate_window_post_proofs,
+    get_window_post_inputs,
 };
 use log::info;
 use serde::{Deserialize, Serialize};
@@ -635,6 +637,7 @@ pub fn run_window_post_bench<Tree: 'static + MerkleTreeTrait>(
         // })
         // .expect("failed to verify window post proof");
     }
+
     let generate_window_post_time = start_time.elapsed().as_millis();
 
     let post_config = PoStConfig {
@@ -650,26 +653,37 @@ pub fn run_window_post_bench<Tree: 'static + MerkleTreeTrait>(
             api_version,
         };
 
-    let start_time = Instant::now();
-    let aggregate_proof = &aggregate_window_post_proofs::<Tree>(&post_config, randomnesses.as_slice(), proofs.as_slice(), 1)?;
-    let aggregate_window_post_proofs_time = start_time.elapsed().as_millis();
+    use rayon::prelude::*;
+    let commit_inputs: Vec<Vec<Fr>> = pub_replica_infos
+        .par_iter()
+        .zip(randomnesses.par_iter())
+        .map(|(replica, randomness)| get_window_post_inputs::<Tree>(&post_config, replica, randomness, PROVER_ID))
+        .try_reduce(Vec::new, |mut acc, current| {
+                println!("{:?}", acc);
+                acc.extend(current);
+                Ok(acc)
+            })?;
 
-    let start_time = Instant::now();
-    let ok = verify_aggregate_window_post_proofs::<Tree>(&post_config, PROVER_ID, aggregate_proof.to_vec(), randomnesses.as_slice(), pub_replica_infos.as_slice())?;
-    let verify_aggregate_proofs_time = start_time.elapsed().as_millis();
+    // let start_time = Instant::now();
+    // let aggregate_proof = &aggregate_window_post_proofs::<Tree>(&post_config, randomnesses.as_slice(), proofs.as_slice(), 1)?;
+    // let aggregate_window_post_proofs_time = start_time.elapsed().as_millis();
+
+    // let start_time = Instant::now();
+    // let ok = verify_aggregate_window_post_proofs::<Tree>(&post_config, PROVER_ID, aggregate_proof.to_vec(), randomnesses.as_slice(), pub_replica_infos.as_slice())?;
+    // let verify_aggregate_proofs_time = start_time.elapsed().as_millis();
     
-    if ok {
-        info!("aggregate proofs is true");
-    } else {
-        info!("aggregate proofs is false");
-    }
+    // if ok {
+    //     info!("aggregate proofs is true");
+    // } else {
+    //     info!("aggregate proofs is false");
+    // }
 
-    info!("#################################################");
-    info!("generate {} window-post using {}", aggregate_count, generate_window_post_time);
-    info!("aggregate {} window-post proofs using {}", aggregate_count, aggregate_window_post_proofs_time);
-    info!("verify_aggregate {} window-post proofs using {}", aggregate_count, verify_aggregate_proofs_time);
-    info!("aggregate proofs size is {}", aggregate_proof.len());
-    info!("#################################################");
+    // info!("#################################################");
+    // info!("generate {} window-post using {}", aggregate_count, generate_window_post_time);
+    // info!("aggregate {} window-post proofs using {}", aggregate_count, aggregate_window_post_proofs_time);
+    // info!("verify_aggregate {} window-post proofs using {}", aggregate_count, verify_aggregate_proofs_time);
+    // info!("aggregate proofs size is {}", aggregate_proof.len());
+    // info!("#################################################");
 
     if preserve_cache {
         info!("Preserving cache directory {:?}", root_dir);

extern/sector-storage/ffiwrapper/verifier_cgo.go

@@ -55,6 +55,14 @@ func (sb *Sealer) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, s
 	return proof, faultyIDs, err
 }
 
+func (sb *Sealer) AggregateWindowPoStProofs(ctx context.Context, aggregateInfo ffi.AggregateWindowPostInfos) ([]byte, error) {
+	for i, random := range(aggregateInfo.Randomnesses) {
+		aggregateInfo.Randomnesses[i][31] = random[31] & 0x3f
+	}
+
+	return ffi.AggregateWindowPoStProofs(aggregateInfo)
+}
+
 func (sb *Sealer) pubSectorToPriv(ctx context.Context, mid abi.ActorID, sectorInfo []proof5.SectorInfo, faults []abi.SectorNumber, rpt func(abi.RegisteredSealProof) (abi.RegisteredPoStProof, error)) (ffi.SortedPrivateSectorInfo, []abi.SectorID, func(), error) {
 	fmap := map[abi.SectorNumber]struct{}{}
 	for _, fault := range faults {
@@ -135,6 +143,14 @@ func (proofVerifier) VerifyWindowPoSt(ctx context.Context, info proof5.WindowPoS
 	return ffi.VerifyWindowPoSt(info)
 }
 
+func (proofVerifier) VerifyAggregateWindowPostProofs(ctx context.Context, aggregateInfo ffi.AggregateWindowPostInfos) (bool, error){
+	for i, random := range(aggregateInfo.Randomnesses) {
+		aggregateInfo.Randomnesses[i][31] = random[31] & 0x3f
+	}
+
+	return ffi.VerifyAggregateWindowPostProofs(aggregateInfo)
+}
+
 func (proofVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, eligibleSectorCount uint64) ([]uint64, error) {
 	randomness[31] &= 0x3f
 	return ffi.GenerateWinningPoStSectorChallenge(proofType, minerID, randomness, eligibleSectorCount)

go.mod

-module fil_integrate
-
-go 1.16
-
-require (
-	github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e
-	github.com/docker/go-units v0.4.0
-	github.com/elastic/go-sysinfo v1.7.0
-	github.com/filecoin-project/filecoin-ffi v0.30.4-0.20200910194244-f640612a1a1f
-	github.com/filecoin-project/go-address v0.0.5
-	github.com/filecoin-project/go-bitfield v0.2.4
-	github.com/filecoin-project/go-commp-utils v0.1.1
-	github.com/filecoin-project/go-fil-commcid v0.1.0
-	github.com/filecoin-project/go-paramfetch v0.0.2-0.20210614165157-25a6c7769498
-	github.com/filecoin-project/go-state-types v0.1.1-0.20210506134452-99b279731c48
-	github.com/filecoin-project/go-statestore v0.1.1
-	github.com/filecoin-project/lotus v1.10.1
-	github.com/filecoin-project/specs-actors v0.9.13
-	github.com/filecoin-project/specs-actors/v2 v2.3.5
-	github.com/filecoin-project/specs-actors/v3 v3.1.1
-	github.com/filecoin-project/specs-actors/v4 v4.0.1
-	github.com/filecoin-project/specs-actors/v5 v5.0.1
-	github.com/filecoin-project/specs-storage v0.1.1-0.20201105051918-5188d9774506
-	github.com/google/uuid v1.2.0
-	github.com/gorilla/mux v1.8.0
-	github.com/hashicorp/go-multierror v1.1.1
-	github.com/ipfs/go-cid v0.0.7
-	github.com/ipfs/go-datastore v0.4.5
-	github.com/ipfs/go-log/v2 v2.3.0
-	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
-	github.com/mitchellh/go-homedir v1.1.0
-	github.com/stretchr/testify v1.7.0
-	github.com/urfave/cli/v2 v2.3.0
-	github.com/whyrusleeping/cbor-gen v0.0.0-20210422071115-ad5b82622e0f
-	go.opencensus.io v0.23.0
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
-	github.com/libp2p/go-libp2p-core v0.8.5
-)
-
-replace github.com/filecoin-project/filecoin-ffi => ./extern/filecoin-ffi
-
-replace github.com/filecoin-project/lotus/chain => ./chain
-
-replace github.com/filecoin-project/go-state-types => ./extern/go-state-types
+module fil_integrate
+
+go 1.16
+
+require (
+	github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e
+	github.com/docker/go-units v0.4.0
+	github.com/elastic/go-sysinfo v1.7.0
+	github.com/filecoin-project/filecoin-ffi v0.30.4-0.20200910194244-f640612a1a1f
+	github.com/filecoin-project/go-address v0.0.5
+	github.com/filecoin-project/go-bitfield v0.2.4
+	github.com/filecoin-project/go-commp-utils v0.1.1
+	github.com/filecoin-project/go-fil-commcid v0.1.0
+	github.com/filecoin-project/go-paramfetch v0.0.2-0.20210614165157-25a6c7769498
+	github.com/filecoin-project/go-state-types v0.1.1-0.20210506134452-99b279731c48
+	github.com/filecoin-project/go-statestore v0.1.1
+	github.com/filecoin-project/lotus v1.10.1
+	github.com/filecoin-project/specs-actors v0.9.13
+	github.com/filecoin-project/specs-actors/v2 v2.3.5
+	github.com/filecoin-project/specs-actors/v3 v3.1.1
+	github.com/filecoin-project/specs-actors/v4 v4.0.1
+	github.com/filecoin-project/specs-actors/v5 v5.0.1
+	github.com/filecoin-project/specs-storage v0.1.1-0.20201105051918-5188d9774506
+	github.com/google/uuid v1.2.0
+	github.com/gorilla/mux v1.8.0
+	github.com/hashicorp/go-multierror v1.1.1
+	github.com/ipfs/go-cid v0.0.7
+	github.com/ipfs/go-datastore v0.4.5
+	github.com/ipfs/go-log/v2 v2.3.0
+	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
+	github.com/mitchellh/go-homedir v1.1.0
+	github.com/stretchr/testify v1.7.0
+	github.com/urfave/cli/v2 v2.3.0
+	github.com/whyrusleeping/cbor-gen v0.0.0-20210422071115-ad5b82622e0f
+	go.opencensus.io v0.23.0
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
+	github.com/libp2p/go-libp2p-core v0.8.5
+)
+
+replace github.com/filecoin-project/filecoin-ffi => ./extern/filecoin-ffi
+
+replace github.com/filecoin-project/lotus/chain => ./chain
+
+replace github.com/filecoin-project/go-state-types => ./extern/go-state-types