feat: integrate submit_windowed_post with pallet proofs

cli/polka-storage-provider/client/src/commands/proofs.rs

@@ -115,13 +115,20 @@ pub enum ProofsCommand {
         /// It must be the same, or else it won't work.
         #[arg(short, long)]
         cache_directory: PathBuf,
+        #[arg(short, long)]
+        /// Directory where the PoSt proof will be stored. Defaults to the current directory.
+        output_path: Option<PathBuf>,
+        /// Sector Number used in the PoRep command.
+        #[arg(long)]
+        sector_number: u32,
+        /// Block Number at which the randomness should be fetched from.
+        /// It comes from the [`pallet_storage_provider::DeadlineInfo::challenge`] field.
+        #[arg(long)]
+        challenge_block: u64,
         /// Replica file generated with `porep` command e.g. `77.sector.sealed`.
         replica_path: PathBuf,
         /// CID - CommR of a replica (output of `porep` command)
         comm_r: String,
-        #[arg(short, long)]
-        /// Directory where the PoSt proof will be stored. Defaults to the current directory.
-        output_path: Option<PathBuf>,
     },
 }
 
@@ -405,16 +412,19 @@ impl ProofsCommand {
                 replica_path,
                 comm_r,
                 output_path,
+                sector_number,
+                challenge_block,
             } => {
                 let Some(signer) = Option::<MultiPairSigner>::from(signer_key) else {
                     return Err(UtilsCommandError::NoSigner)?;
                 };
-                let prover_id = derive_prover_id(signer.account_id());
 
-                // Those are hardcoded for the showcase only.
-                // They should come from Storage Provider Node, precommits and other information.
-                let sector_id = 77.into();
-                let randomness = [1u8; 32];
+                let entropy = signer.account_id().encode();
+                let randomness = get_randomness(
+                    DomainSeparationTag::WindowedPoStChallengeSeed,
+                    challenge_block,
+                    &entropy,
+                );
 
                 let output_path = if let Some(output_path) = output_path {
                     output_path
@@ -424,15 +434,18 @@ impl ProofsCommand {
 
                 let (proof_scale_filename, mut proof_scale_file) = file_with_extension(
                     &output_path,
-                    format!("{}", sector_id).as_str(),
+                    format!("{}", sector_number).as_str(),
                     POST_PROOF_EXT,
                 )?;
 
                 let comm_r =
                     cid::Cid::from_str(&comm_r).map_err(|_| UtilsCommandError::CommRError)?;
 
+                let sector_number = SectorNumber::try_from(sector_number)
+                    .map_err(|_| UtilsCommandError::InvalidSectorId)?;
+
                 let replicas = vec![ReplicaInfo {
-                    sector_id,
+                    sector_id: sector_number,
                     comm_r: comm_r
                         .hash()
                         .digest()
@@ -445,6 +458,7 @@ impl ProofsCommand {
                 let proof_parameters = post::load_groth16_parameters(proof_parameters_path)
                     .map_err(|e| UtilsCommandError::GeneratePoStError(e))?;
 
+                let prover_id = derive_prover_id(signer.account_id());
                 let proofs = post::generate_window_post(
                     post_type,
                     &proof_parameters,

cli/polka-storage-provider/server/src/pipeline/mod.rs

@@ -325,7 +325,11 @@ async fn precommit(
         })
     };
     let sealing_output = sealing_handle.await??;
-    tracing::info!("Created sector's replica: {:?}", sealing_output);
+    tracing::info!(
+        "Created sector's replica, CommD: {}, CommR: {}",
+        sealing_output.comm_d.cid(),
+        sealing_output.comm_r.cid()
+    );
 
     let sealing_output_commr = Commitment::<CommR>::from(sealing_output.comm_r);
     let sealing_output_commd = Commitment::<CommD>::from(sealing_output.comm_d);

examples/rpc_publish.sh

@@ -35,11 +35,9 @@ target/release/storagext-cli --sr25519-key "$PROVIDER" market add-balance 250000
 # register one of them as the storage provider
 wait
 
-# Register the SP
-target/release/storagext-cli --sr25519-key "$PROVIDER" storage-provider register "peer_id"
-
-# Set PoRep verifying key
-target/release/storagext-cli --sr25519-key "$PROVIDER" proofs set-porep-verifying-key @2KiB.porep.vk.scale
+target/release/storagext-cli --sr25519-key "//Charlie" storage-provider register "peer_id"
+target/release/storagext-cli --sr25519-key "//Charlie" proofs set-porep-verifying-key @2KiB.porep.vk.scale
+target/release/storagext-cli --sr25519-key "//Charlie" proofs set-post-verifying-key @2KiB.post.vk.scale
 
 DEAL_JSON=$(
     jq -n \

pallets/storage-provider/Cargo.toml

@@ -57,6 +57,7 @@ std = [
   "frame-support/std",
   "frame-system/std",
   "pallet-balances/std",
+  "primitives-proofs/std",
   "scale-info/std",
   "sp-core/std",
   "sp-io/std",

pallets/storage-provider/src/lib.rs

@@ -59,8 +59,8 @@ pub mod pallet {
     use primitives_proofs::{
         derive_prover_id,
         randomness::{draw_randomness, DomainSeparationTag},
-        Market, ProofVerification, Randomness, RegisteredPoStProof, SectorNumber,
-        StorageProviderValidation, MAX_SEAL_PROOF_BYTES, MAX_SECTORS_PER_CALL,
+        Market, ProofVerification, PublicReplicaInfo, Randomness, RegisteredPoStProof,
+        SectorNumber, StorageProviderValidation, MAX_SEAL_PROOF_BYTES, MAX_SECTORS_PER_CALL,
     };
     use scale_info::TypeInfo;
     use sp_arithmetic::traits::Zero;
@@ -321,6 +321,8 @@ pub mod pallet {
         StorageProviderNotFound,
         /// Emitted when trying to access an invalid sector.
         InvalidSector,
+        /// Emitted when trying to submit PoSt for an not-existing partition for a deadline.
+        InvalidPartition,
         /// Emitted when submitting an invalid proof type.
         InvalidProofType,
         /// Emitted when the proof is invalid
@@ -362,6 +364,8 @@ pub mod pallet {
         CouldNotTerminateDeals,
         /// Tried to terminate sectors that are not mutable.
         CannotTerminateImmutableDeadline,
+        /// Emitted when trying to submit PoSt with partitions containing too many sectors (>2349).
+        TooManyReplicas,
         /// Inner pallet errors
         GeneralPalletError(crate::error::GeneralPalletError),
     }
@@ -662,8 +666,6 @@ pub mod pallet {
         }
 
         /// The SP uses this extrinsic to submit their Proof-of-Spacetime.
-        ///
-        /// * Currently the proof is considered valid when `proof.len() > 0`.
         pub fn submit_windowed_post(
             origin: OriginFor<T>,
             windowed_post: SubmitWindowedPoStParams,
@@ -687,13 +689,14 @@ pub mod pallet {
                 }
             );
 
-            // Ensure a valid proof size
-            // TODO(@jmg-duarte,#91,19/8/24): correctly check the length
-            // https://github.com/filecoin-project/builtin-actors/blob/17ede2b256bc819dc309edf38e031e246a516486/actors/miner/src/lib.rs#L565-L573
-            ensure!(windowed_post.proof.proof_bytes.len() > 0, {
-                log::error!("submit_window_post: invalid proof size");
-                Error::<T>::PoStProofInvalid
-            });
+            ensure!(
+                windowed_post.proof.proof_bytes.len()
+                    <= primitives_proofs::MAX_POST_PROOF_BYTES as usize,
+                {
+                    log::error!("submit_window_post: invalid proof size");
+                    Error::<T>::PoStProofInvalid
+                }
+            );
 
             // If the proving period is in the future, we can't submit a proof yet
             // Related issue: https://github.com/filecoin-project/specs-actors/issues/946
@@ -718,6 +721,52 @@ pub mod pallet {
 
             Self::validate_deadline(&current_deadline, &windowed_post)?;
 
+            // record sector as proven
+            let all_sectors = sp.sectors.clone();
+            let deadlines = sp.get_deadlines_mut();
+            deadlines
+                .record_proven(
+                    windowed_post.deadline as usize,
+                    &all_sectors,
+                    windowed_post.partitions.clone(),
+                )
+                .map_err(|e| Error::<T>::GeneralPalletError(e))?;
+
+            // TODO(@th7nder,#592, 19/11/2024): handle faulty and recovered sectors, we don't take them into account now
+            let deadlines = &sp.deadlines;
+            let mut replicas = BoundedBTreeMap::new();
+            // Take all the sectors that were assigned to all of the partitions
+            for partition in &windowed_post.partitions {
+                // Deadline is validated by `Self::validate_deadline`, so we're sure it can be used as an index.
+                let deadline = &deadlines.due[windowed_post.deadline as usize];
+                let sectors = &deadline
+                    .partitions
+                    .get(&partition)
+                    .ok_or(Error::<T>::InvalidPartition)?
+                    .sectors;
+                for sector_number in sectors {
+                    // Sectors stored in the Storage Provider struct should be consistently stored, without breaking invariants.
+                    let sector_info = &sp.sectors[sector_number];
+                    let comm_r = Commitment::<CommR>::from_cid_bytes(&sector_info.sealed_cid)
+                        .expect("CommR to be validated on pre-commit");
+                    let _ = replicas
+                        .try_insert(
+                            *sector_number,
+                            PublicReplicaInfo {
+                                comm_r: comm_r.raw(),
+                            },
+                        )
+                        .map_err(|_| Error::<T>::TooManyReplicas)?;
+                }
+            }
+
+            log::debug!(target: LOG_TARGET, "submit_windowed_post: index {:?} challenge {:?}, replicas: {:?}",
+                current_deadline.idx,
+                current_deadline.challenge,
+                replicas
+            );
+
+            let entropy = owner.encode();
             // The `chain_commit_epoch` should be `current_deadline.challenge` as per:
             //
             // These issues that were filed against the original implementation:
@@ -737,25 +786,23 @@ pub mod pallet {
             // * https://github.com/filecoin-project/lotus/blob/4f70204342ce83671a7a261147a18865f1618967/storage/wdpost/wdpost_run.go#L334-L338
             // * https://github.com/filecoin-project/lotus/blob/4f70204342ce83671a7a261147a18865f1618967/curiosrc/window/compute_do.go#L68-L72
             // * https://github.com/filecoin-project/curio/blob/45373f7fc0431e41f987ad348df7ae6e67beaff9/tasks/window/compute_do.go#L71-L75
+            let randomness = get_randomness::<T>(
+                DomainSeparationTag::WindowedPoStChallengeSeed,
+                current_deadline.challenge,
+                &entropy,
+            )?;
 
-            // TODO(@aidan46, #91, 2024-07-03): Validate the proof after research is done
+            T::ProofVerification::verify_post(
+                windowed_post.proof.post_proof,
+                randomness,
+                replicas,
+                windowed_post.proof.proof_bytes,
+            )?;
 
-            // record sector as proven
-            let all_sectors = sp.sectors.clone();
-            let deadlines = sp.get_deadlines_mut();
-            deadlines
-                .record_proven(
-                    windowed_post.deadline as usize,
-                    &all_sectors,
-                    windowed_post.partitions,
-                )
-                .map_err(|e| Error::<T>::GeneralPalletError(e))?;
+            log::debug!(target: LOG_TARGET, "submit_windowed_post: proof recorded");
 
             // Store new storage provider state
             StorageProviders::<T>::set(owner.clone(), Some(sp));
-
-            log::debug!(target: LOG_TARGET, "submit_windowed_post: proof recorded");
-
             Self::deposit_event(Event::ValidPoStSubmitted { owner });
 
             Ok(())
@@ -1019,6 +1066,36 @@ pub mod pallet {
     }
 
     impl<T: Config> Pallet<T> {
+        /// Gets the current deadline of the storage provider.
+        ///
+        /// If there is no Storage Provider of given AccountId returns [`Option::None`].
+        /// May exceptionally return [`Option::None`] when
+        /// conversion between BlockNumbers fails, but technically should not ever happen.
+        pub fn current_deadline(
+            storage_provider: &T::AccountId,
+        ) -> Option<primitives_proofs::CurrentDeadline<BlockNumberFor<T>>> {
+            let sp = StorageProviders::<T>::try_get(storage_provider).ok()?;
+            let current_block = <frame_system::Pallet<T>>::block_number();
+
+            let deadline = sp
+                .deadline_info(
+                    current_block,
+                    T::WPoStPeriodDeadlines::get(),
+                    T::WPoStProvingPeriod::get(),
+                    T::WPoStChallengeWindow::get(),
+                    T::WPoStChallengeLookBack::get(),
+                    T::FaultDeclarationCutoff::get(),
+                )
+                .ok()?;
+
+            Some(primitives_proofs::CurrentDeadline {
+                deadline_index: deadline.idx,
+                open: deadline.is_open(),
+                challenge_block: deadline.challenge,
+                start: deadline.open_at,
+            })
+        }
+
         fn validate_expiration(
             curr_block: BlockNumberFor<T>,
             activation: BlockNumberFor<T>,

pallets/storage-provider/src/proofs.rs

@@ -3,7 +3,7 @@ use frame_support::{
     pallet_prelude::{ConstU32, RuntimeDebug},
     sp_runtime::BoundedVec,
 };
-use primitives_proofs::RegisteredPoStProof;
+use primitives_proofs::{RegisteredPoStProof, MAX_POST_PROOF_BYTES};
 use scale_info::TypeInfo;
 use sp_core::blake2_64;
 
@@ -14,8 +14,8 @@ use crate::partition::{PartitionNumber, MAX_PARTITIONS_PER_DEADLINE};
 pub struct PoStProof {
     /// The proof type, currently only one type is supported.
     pub post_proof: RegisteredPoStProof,
-    /// The proof submission, to be checked in the storage provider pallet.
-    pub proof_bytes: BoundedVec<u8, ConstU32<256>>, // Arbitrary length
+    /// The proof submission, to be checked by [`ProofVerification::verify_post`], usually [`pallet_proofs`].
+    pub proof_bytes: BoundedVec<u8, ConstU32<MAX_POST_PROOF_BYTES>>,
 }
 
 /// Parameter type for `submit_windowed_post` extrinsic.

pallets/storage-provider/src/tests/mod.rs

@@ -80,6 +80,8 @@ impl pallet_balances::Config for Test {
     type AccountStore = System;
 }
 
+pub const INVALID_PROOF: [u8; 2] = [0xd, 0xe];
+
 /// This is dummy proofs pallet implementation. All proofs are accepted as valid
 pub struct DummyProofsVerification;
 impl ProofVerification for DummyProofsVerification {
@@ -104,8 +106,11 @@ impl ProofVerification for DummyProofsVerification {
             PublicReplicaInfo,
             ConstU32<MAX_SECTORS_PER_PROOF>,
         >,
-        _proof: BoundedVec<u8, ConstU32<MAX_POST_PROOF_BYTES>>,
+        proof: BoundedVec<u8, ConstU32<MAX_POST_PROOF_BYTES>>,
     ) -> sp_runtime::DispatchResult {
+        if *proof == INVALID_PROOF {
+            return Err(sp_runtime::DispatchError::Other("invalid proof"));
+        }
         Ok(())
     }
 }

pallets/storage-provider/src/tests/submit_windowed_post.rs

@@ -12,7 +12,7 @@ use crate::{
         account, declare_faults::setup_sp_with_many_sectors_multiple_partitions, events,
         new_test_ext, register_storage_provider, run_to_block, DealProposalBuilder, Market,
         RuntimeEvent, RuntimeOrigin, SectorPreCommitInfoBuilder, StorageProvider,
-        SubmitWindowedPoStBuilder, System, Test, ALICE, BOB,
+        SubmitWindowedPoStBuilder, System, Test, ALICE, BOB, INVALID_PROOF,
     },
     Config,
 };
@@ -349,7 +349,8 @@ fn fail_windowed_post_wrong_signature() {
 
         // Build window post proof
         let windowed_post = SubmitWindowedPoStBuilder::default()
-            .proof_bytes(vec![]) // Wrong proof
+            .partition(0)
+            .proof_bytes(INVALID_PROOF.into())
             .build();
 
         // Run extrinsic
@@ -358,7 +359,7 @@ fn fail_windowed_post_wrong_signature() {
                 RuntimeOrigin::signed(account(ALICE)),
                 windowed_post,
             ),
-            Error::<Test>::PoStProofInvalid
+            DispatchError::Other("invalid proof")
         );
     });
 }