Review updates

Author: NemanjaLu92

actors/miner/src/lib.rs

@@ -781,7 +781,12 @@ impl Actor {
             return Err(actor_error!(illegal_argument, "no sectors"));
         }
 
-        validate_seal_aggregate_proof(&params.aggregate_proof, sector_numbers.len(), policy)?;
+        validate_seal_aggregate_proof(
+            &params.aggregate_proof,
+            sector_numbers.len(),
+            policy,
+            false,
+        )?;
 
         // Load and validate pre-commits.
         // Fail if any don't exist, but otherwise continue with valid ones.
@@ -1801,6 +1806,7 @@ impl Actor {
                 &params.aggregate_proof,
                 params.sector_activations.len() as u64,
                 policy,
+                false,
             )?;
         }
 
@@ -1961,13 +1967,6 @@ impl Actor {
 
         if params.sectors.is_empty() {
             return Err(actor_error!(illegal_argument, "batch empty"));
-        } else if params.sectors.len() > policy.prove_commit_ni_sector_batch_max_size {
-            return Err(actor_error!(
-                illegal_argument,
-                "batch of {} too large, max {}",
-                params.sectors.len(),
-                policy.pre_commit_sector_batch_max_size
-            ));
         }
 
         if !can_prove_commit_ni_seal_proof(rt.policy(), params.seal_proof_type) {
@@ -1978,51 +1977,53 @@ impl Actor {
             ));
         }
 
-        if params.sector_proofs.is_empty() == params.aggregate_proof.is_empty() {
+        if params.aggregate_proof.is_empty() {
+            return Err(actor_error!(illegal_argument, "aggregate proof must be non-empty"));
+        }
+
+        if params.aggregate_proof_type != RegisteredAggregateProof::SnarkPackV2 {
+            return Err(actor_error!(illegal_argument, "aggregate proof type must be SnarkPackV2"));
+        }
+
+        let sector_count = params.sectors.len() as u64;
+        if sector_count > policy.max_aggregated_sectors_ni {
             return Err(actor_error!(
                 illegal_argument,
-                "exactly one of sector proofs or aggregate proof must be non-empty"
+                "too many sectors addressed, addressed {} want <= {}",
+                sector_count,
+                policy.max_aggregated_sectors
             ));
         }
-
-        if !params.sector_proofs.is_empty() {
-            // Batched proofs, one per sector
-            if params.aggregate_proof_type.is_some() {
-                return Err(actor_error!(
-                    illegal_argument,
-                    "aggregate proof type must be null with batched proofs"
-                ));
-            }
-            if params.sectors.len() != params.sector_proofs.len() {
-                return Err(actor_error!(
-                    illegal_argument,
-                    "mismatched lengths: {} sectors, {} proofs",
-                    params.sectors.len(),
-                    params.sector_proofs.len()
-                ));
-            }
-            validate_seal_proofs(params.seal_proof_type, &params.sector_proofs)?;
-        } else {
-            if params.aggregate_proof_type != Some(RegisteredAggregateProof::SnarkPackV2) {
-                return Err(actor_error!(
-                    illegal_argument,
-                    "aggregate proof type must be SnarkPackV2"
-                ));
-            }
-            validate_seal_aggregate_proof(
-                &params.aggregate_proof,
-                params.sectors.len() as u64,
-                policy,
-            )?;
+        if sector_count < policy.min_aggregated_sectors_ni {
+            return Err(actor_error!(
+                illegal_argument,
+                "too few sectors addressed, addressed {} want >= {}",
+                sector_count,
+                policy.min_aggregated_sectors_ni
+            ));
         }
 
+        validate_seal_aggregate_proof(
+            &params.aggregate_proof,
+            params.sectors.len() as u64,
+            policy,
+            true,
+        )?;
+
         if params.sectors.iter().any(|sector| sector.sealer_id != miner_id) {
             return Err(actor_error!(
                 illegal_argument,
                 "all sectors must be sealed for the same receiver actor"
             ));
         }
 
+        if params.sectors.iter().any(|sector| sector.sector_number != sector.sealing_number) {
+            return Err(actor_error!(
+                illegal_argument,
+                "all sealing number must be same as sector numbers"
+            ));
+        }
+
         let curr_epoch = rt.curr_epoch();
         let challenge_earliest = curr_epoch - rt.policy().max_prove_commit_ni_randomness_lookback;
         let unsealed_cid = CompactCommD::empty().get_cid(params.seal_proof_type).unwrap();
@@ -2068,47 +2069,13 @@ impl Actor {
             info.control_addresses.iter().chain(&[info.worker, info.owner]),
         )?;
 
-        let base_sector_power = base_power_for_sector(info.sector_size);
-
-        let rew = request_current_epoch_block_reward(rt)?;
-        let pwr = request_current_total_power(rt)?;
-        let circulating_supply = rt.total_fil_circ_supply();
-        let pledge_inputs = NetworkPledgeInputs {
-            network_qap: pwr.quality_adj_power_smoothed,
-            network_baseline: rew.this_epoch_baseline_power,
-            circulating_supply,
-            epoch_reward: rew.this_epoch_reward_smoothed,
-        };
-
-        let initial_pledge = initial_pledge_for_power(
-            &base_sector_power,
-            &pledge_inputs.network_baseline,
-            &pledge_inputs.epoch_reward,
-            &pledge_inputs.network_qap,
-            &pledge_inputs.circulating_supply,
-        );
-
-        let day_reward = expected_reward_for_power(
-            &pledge_inputs.epoch_reward,
-            &pledge_inputs.network_qap,
-            &base_sector_power,
-            fil_actors_runtime::EPOCHS_IN_DAY,
-        );
-
-        let storage_pledge = expected_reward_for_power(
-            &pledge_inputs.epoch_reward,
-            &pledge_inputs.network_qap,
-            &base_sector_power,
-            INITIAL_PLEDGE_PROJECTION_PERIOD,
-        );
-
         let proof_inputs = params
             .sectors
             .iter()
             .map(|sector| -> Result<SectorSealProofInput, ActorError> {
                 Ok(SectorSealProofInput {
                     registered_proof: params.seal_proof_type,
-                    sector_number: sector.sector_number,
+                    sector_number: sector.sealing_number,
                     randomness: Randomness(
                         rt.get_randomness_from_tickets(
                             DomainSeparationTag::SealRandomness,
@@ -2135,56 +2102,53 @@ impl Actor {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let verified_sectors = if !params.sector_proofs.is_empty() {
-            let sector_verify_info = proof_inputs
-                .iter()
-                .zip(params.sector_proofs.into_iter())
-                .map(|(proof_inputs, proof)| SealVerifyInfo {
-                    registered_proof: params.seal_proof_type,
-                    sector_id: fvm_shared::sector::SectorID {
-                        miner: miner_id,
-                        number: proof_inputs.sector_number,
-                    },
-                    randomness: proof_inputs.randomness.clone(),
-                    proof: proof.into(),
-                    sealed_cid: proof_inputs.sealed_cid,
-                    unsealed_cid,
-                    deal_ids: vec![],
-                    interactive_randomness: proof_inputs.interactive_randomness.clone(),
-                })
-                .collect::<Vec<_>>();
+        verify_aggregate_seal(
+            rt,
+            // All the proof inputs, even for invalid pre-commits,
+            // must be provided as witnesses to the aggregate proof.
+            &proof_inputs,
+            params.sectors[0].sealer_id,
+            params.seal_proof_type,
+            params.aggregate_proof_type,
+            &params.aggregate_proof,
+        )?;
 
-            let sector_verifications = rt
-                .batch_verify_seals(&sector_verify_info)
-                .context_code(ExitCode::USR_ILLEGAL_ARGUMENT, "failed to batch verify")?;
-            log::info!("sector_verifications: {:?}", sector_verifications);
-            params
-                .sectors
-                .into_iter()
-                .zip(sector_verifications)
-                .filter(|(_, verified)| *verified)
-                .map(|(sector, _)| sector)
-                .collect::<Vec<_>>()
-        } else {
-            verify_aggregate_seal(
-                rt,
-                // All the proof inputs, even for invalid pre-commits,
-                // must be provided as witnesses to the aggregate proof.
-                &proof_inputs,
-                miner_id,
-                params.seal_proof_type,
-                params.aggregate_proof_type.unwrap(),
-                &params.aggregate_proof,
-            )?;
+        let base_sector_power = base_power_for_sector(info.sector_size);
 
-            params.sectors
+        let rew = request_current_epoch_block_reward(rt)?;
+        let pwr = request_current_total_power(rt)?;
+        let circulating_supply = rt.total_fil_circ_supply();
+        let pledge_inputs = NetworkPledgeInputs {
+            network_qap: pwr.quality_adj_power_smoothed,
+            network_baseline: rew.this_epoch_baseline_power,
+            circulating_supply,
+            epoch_reward: rew.this_epoch_reward_smoothed,
         };
 
-        if verified_sectors.is_empty() {
-            return Err(actor_error!(illegal_argument, "no valid proofs specified"));
-        }
+        let initial_pledge = initial_pledge_for_power(
+            &base_sector_power,
+            &pledge_inputs.network_baseline,
+            &pledge_inputs.epoch_reward,
+            &pledge_inputs.network_qap,
+            &pledge_inputs.circulating_supply,
+        );
+
+        let day_reward = expected_reward_for_power(
+            &pledge_inputs.epoch_reward,
+            &pledge_inputs.network_qap,
+            &base_sector_power,
+            fil_actors_runtime::EPOCHS_IN_DAY,
+        );
 
-        let sectors_to_add = verified_sectors
+        let storage_pledge = expected_reward_for_power(
+            &pledge_inputs.epoch_reward,
+            &pledge_inputs.network_qap,
+            &base_sector_power,
+            INITIAL_PLEDGE_PROJECTION_PERIOD,
+        );
+
+        let sectors_to_add = params
+            .sectors
             .iter()
             .map(|sector| SectorOnChainInfo {
                 sector_number: sector.sector_number,
@@ -2204,8 +2168,10 @@ impl Actor {
                 flags: SectorOnChainInfoFlags::SIMPLE_QA_POWER,
             })
             .collect::<Vec<SectorOnChainInfo>>();
+        let sectors_len = sectors_to_add.len();
 
-        let total_pledge = BigInt::from(sectors_to_add.len()) * initial_pledge;
+        let total_pledge = BigInt::from(sectors_len) * initial_pledge;
+        let mut needs_cron = false;
 
         rt.transaction(|state: &mut State, rt| {
             let current_balance = rt.current_balance();
@@ -2222,6 +2188,8 @@ impl Actor {
                     available_balance
                 ));
             }
+            needs_cron = !state.deadline_cron_active;
+            state.deadline_cron_active = true;
 
             state
                 .put_sectors(store, sectors_to_add.clone())
@@ -2253,6 +2221,17 @@ impl Actor {
             Ok(())
         })?;
 
+        pay_aggregate_seal_proof_fee(rt, sectors_len)?;
+
+        if needs_cron {
+            let new_dl_info = state.deadline_info(rt.policy(), curr_epoch);
+            enroll_cron_event(
+                rt,
+                new_dl_info.last(),
+                CronEventPayload { event_type: CRON_EVENT_PROVING_DEADLINE },
+            )?;
+        }
+
         Ok(())
     }
 
@@ -5094,20 +5073,26 @@ fn validate_seal_aggregate_proof(
     proof: &RawBytes,
     sector_count: u64,
     policy: &Policy,
+    interactive: bool,
 ) -> Result<(), ActorError> {
-    if sector_count > policy.max_aggregated_sectors {
+    let (min, max) = match interactive {
+        true => (policy.min_aggregated_sectors_ni, policy.max_aggregated_sectors_ni),
+        false => (policy.min_aggregated_sectors, policy.max_aggregated_sectors),
+    };
+
+    if sector_count > max {
         return Err(actor_error!(
             illegal_argument,
             "too many sectors addressed, addressed {} want <= {}",
             sector_count,
-            policy.max_aggregated_sectors
+            max
         ));
-    } else if sector_count < policy.min_aggregated_sectors {
+    } else if sector_count < min {
         return Err(actor_error!(
             illegal_argument,
             "too few sectors addressed, addressed {} want >= {}",
             sector_count,
-            policy.min_aggregated_sectors
+            min
         ));
     }
     if proof.len() > policy.max_aggregated_proof_size {

actors/miner/src/types.rs

@@ -150,16 +150,20 @@ pub struct SectorNIActivationInfo {
 pub struct ProveCommitSectorsNIParams {
     // Information about sealing of each sector.
     pub sectors: Vec<SectorNIActivationInfo>,
-    // Proof type for each seal (must be an NI-PoRep variant)
-    pub seal_proof_type: RegisteredSealProof,
-    // Proofs for each sector, parallel to activation manifests.
-    // Exactly one of sector_proofs or aggregate_proof must be non-empty.
-    pub sector_proofs: Vec<RawBytes>,
+
     // Aggregate proof for all sectors.
     // Exactly one of sector_proofs or aggregate_proof must be non-empty.
     pub aggregate_proof: RawBytes,
+
+    // Proof type for each seal (must be an NI-PoRep variant)
+    pub seal_proof_type: RegisteredSealProof,
+
     // Proof type for aggregation, if aggregated
-    pub aggregate_proof_type: Option<RegisteredAggregateProof>,
+    pub aggregate_proof_type: RegisteredAggregateProof,
+
+    // The Window PoST deadline index at which to schedule the new sectors
+    pub proving_deadline: u64,
+
     // Whether to abort if any sector activation fails.
     pub require_activation_success: bool,
 }