All tests passing

integration_tests/src/tests/batch_onboarding_deals_test.rs

@@ -144,7 +144,7 @@ pub fn batch_onboarding_deals_test(v: &dyn VM) {
     // Associate deals with sectors.
     let sector_precommit_data = deals
         .into_iter()
-        .map(|(id, _)| precommit_meta_data_from_deals(v, &[id], SEAL_PROOF))
+        .map(|(id, _)| precommit_meta_data_from_deals(v, &[id], SEAL_PROOF, true))
         .collect();
 
     // Pre-commit as single batch.

integration_tests/src/tests/commit_post_test.rs

@@ -14,7 +14,7 @@ use crate::expects::Expect;
 use crate::util::{
     advance_by_deadline_to_epoch, advance_to_proving_deadline, assert_invariants, create_accounts,
     create_miner, cron_tick, expect_invariants, get_network_stats, invariant_failure_patterns,
-    miner_balance, miner_prove_sector, precommit_sectors_v2, submit_windowed_post,
+    miner_balance, miner_prove_cc_sector, precommit_sectors_v2, submit_windowed_post,
 };
 use crate::TEST_VM_RAND_ARRAY;
 use fil_actor_cron::Method as CronMethod;
@@ -82,7 +82,7 @@ fn setup(v: &dyn VM) -> (MinerInfo, SectorInfo) {
     advance_by_deadline_to_epoch(v, &id_addr, prove_time);
 
     // prove commit, cron, advance to post time
-    miner_prove_sector(v, &worker, &id_addr, sector_number);
+    miner_prove_cc_sector(v, &worker, &id_addr, sector_number);
     cron_tick(v);
 
     ExpectInvocation {

integration_tests/src/tests/extend_sectors_test.rs

@@ -26,11 +26,11 @@ use crate::expects::Expect;
 use crate::util::{
     advance_by_deadline_to_epoch, advance_by_deadline_to_epoch_while_proving,
     advance_by_deadline_to_index, advance_to_proving_deadline, bf_all, create_accounts,
-    create_miner, cron_tick, expect_invariants, invariant_failure_patterns, market_add_balance,
-    market_pending_deal_allocations, market_publish_deal, miner_precommit_one_sector_v2,
-    miner_prove_sector, override_compute_unsealed_sector_cid, precommit_meta_data_from_deals,
-    sector_deadline, submit_windowed_post, verifreg_add_client, verifreg_add_verifier,
-    PrecommitMetadata,
+    create_miner, cron_tick, expect_invariants, invariant_failure_patterns,
+    make_piece_manifests_from_deal_ids, market_add_balance, market_pending_deal_allocations,
+    market_publish_deal, miner_precommit_one_sector_v2, miner_prove_cc_sector, miner_prove_sector,
+    override_compute_unsealed_sector_cid, precommit_meta_data_from_deals, sector_deadline,
+    submit_windowed_post, verifreg_add_client, verifreg_add_verifier, PrecommitMetadata,
 };
 
 #[allow(clippy::too_many_arguments)]
@@ -165,14 +165,20 @@ pub fn extend_legacy_sector_with_deals_test(v: &dyn VM, do_extend2: bool) {
         &miner_id,
         seal_proof,
         sector_number,
-        precommit_meta_data_from_deals(v, &deals, seal_proof),
+        precommit_meta_data_from_deals(v, &deals, seal_proof, false),
         true,
         deal_start + 180 * EPOCHS_IN_DAY,
     );
 
     // advance time to max seal duration and prove the sector
     advance_by_deadline_to_epoch(v, &miner_id, deal_start);
-    miner_prove_sector(v, &worker, &miner_id, sector_number);
+    miner_prove_sector(
+        v,
+        &worker,
+        &miner_id,
+        sector_number,
+        make_piece_manifests_from_deal_ids(v, deals),
+    );
     // trigger cron to validate the prove commit
     cron_tick(v);
 
@@ -393,14 +399,20 @@ pub fn commit_sector_with_max_duration_deal_test(v: &dyn VM) {
         &miner_id,
         seal_proof,
         sector_number,
-        precommit_meta_data_from_deals(v, &deals, seal_proof),
+        precommit_meta_data_from_deals(v, &deals, seal_proof, false),
         true,
         deal_start + deal_lifetime,
     );
 
     // advance time to max seal duration and prove the sector
     advance_by_deadline_to_epoch(v, &miner_id, deal_start);
-    miner_prove_sector(v, &worker, &miner_id, sector_number);
+    miner_prove_sector(
+        v,
+        &worker,
+        &miner_id,
+        sector_number,
+        make_piece_manifests_from_deal_ids(v, deals),
+    );
     // trigger cron to validate the prove commit
     cron_tick(v);
 
@@ -465,7 +477,7 @@ pub fn extend_sector_up_to_max_relative_extension_test(v: &dyn VM) {
 
     // advance time to max seal duration and prove the sector
     advance_by_deadline_to_epoch(v, &miner_id, sector_start);
-    miner_prove_sector(v, &worker, &miner_id, sector_number);
+    miner_prove_cc_sector(v, &worker, &miner_id, sector_number);
     // trigger cron to validate the prove commit
     cron_tick(v);
 
@@ -566,7 +578,7 @@ pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
     // advance time by a day and prove the sector
     let prove_epoch = v.epoch() + EPOCHS_IN_DAY;
     advance_by_deadline_to_epoch(v, &miner_addr, prove_epoch);
-    miner_prove_sector(v, &worker, &miner_addr, sector_number);
+    miner_prove_cc_sector(v, &worker, &miner_addr, sector_number);
     // trigger cron to validate the prove commit
     cron_tick(v);
 

integration_tests/src/tests/replica_update_test.rs

@@ -36,7 +36,7 @@ use crate::util::{
     assert_invariants, bf_all, check_sector_active, check_sector_faulty, create_accounts,
     create_miner, cron_tick, deadline_state, declare_recovery, expect_invariants, get_deal_weights,
     get_network_stats, invariant_failure_patterns, make_bitfield, market_publish_deal,
-    miner_balance, miner_power, miner_prove_sector, override_compute_unsealed_sector_cid,
+    miner_balance, miner_power, miner_prove_cc_sector, override_compute_unsealed_sector_cid,
     precommit_sectors_v2, prove_commit_sectors, sector_info, submit_invalid_post,
     submit_windowed_post, verifreg_add_client, verifreg_add_verifier,
 };
@@ -1187,7 +1187,7 @@ pub fn create_sector(
     // prove commit
     let prove_time = v.epoch() + Policy::default().pre_commit_challenge_delay + 1;
     advance_by_deadline_to_epoch(v, &maddr, prove_time);
-    miner_prove_sector(v, &worker, &maddr, sector_number);
+    miner_prove_cc_sector(v, &worker, &maddr, sector_number);
 
     cron_tick(v);
 

integration_tests/src/tests/terminate_test.rs

@@ -32,9 +32,9 @@ use crate::expects::Expect;
 use crate::util::{
     advance_by_deadline_to_epoch, advance_by_deadline_to_epoch_while_proving,
     advance_to_proving_deadline, assert_invariants, create_accounts, create_miner, cron_tick,
-    deal_cid_for_testing, make_bitfield, market_publish_deal, miner_balance,
-    miner_precommit_one_sector_v2, miner_prove_sector, precommit_meta_data_from_deals,
-    submit_windowed_post, verifreg_add_verifier,
+    deal_cid_for_testing, make_bitfield, make_piece_manifests_from_deal_ids, market_publish_deal,
+    miner_balance, miner_precommit_one_sector_v2, miner_prove_sector,
+    precommit_meta_data_from_deals, submit_windowed_post, verifreg_add_verifier,
 };
 
 #[vm_test]
@@ -167,15 +167,19 @@ pub fn terminate_sectors_test(v: &dyn VM) {
         &miner_robust_addr,
         seal_proof,
         sector_number,
-        precommit_meta_data_from_deals(v, &deal_ids, seal_proof),
+        precommit_meta_data_from_deals(v, &deal_ids, seal_proof, false),
         true,
         v.epoch() + 220 * EPOCHS_IN_DAY,
     );
     let prove_time = v.epoch() + Policy::default().pre_commit_challenge_delay + 1;
     advance_by_deadline_to_epoch(v, &miner_id_addr, prove_time);
-
-    // prove commit, cron, advance to post time
-    miner_prove_sector(v, &worker, &miner_id_addr, sector_number);
+    miner_prove_sector(
+        v,
+        &worker,
+        &miner_id_addr,
+        sector_number,
+        make_piece_manifests_from_deal_ids(v, deal_ids.clone()),
+    );
 
     let (dline_info, p_idx) = advance_to_proving_deadline(v, &miner_id_addr, sector_number);
     let d_idx = dline_info.index;

integration_tests/src/tests/verified_claim_test.rs

@@ -1,8 +1,10 @@
 use std::ops::Neg;
 
 use export_macro::vm_test;
+use fvm_ipld_encoding::RawBytes;
 use fvm_shared::bigint::Zero;
 use fvm_shared::econ::TokenAmount;
+use fvm_shared::error::ExitCode;
 use fvm_shared::piece::PaddedPieceSize;
 use fvm_shared::sector::{RegisteredSealProof, SectorNumber, StoragePower};
 
@@ -11,7 +13,10 @@ use fil_actor_market::{DealArray, DealMetaArray, DealSettlementSummary};
 use fil_actor_market::{
     PendingDealAllocationsMap, State as MarketState, PENDING_ALLOCATIONS_CONFIG,
 };
-use fil_actor_miner::{max_prove_commit_duration, PowerPair, SectorClaim, State as MinerState};
+use fil_actor_miner::{
+    max_prove_commit_duration, PowerPair, ProveCommitSectors3Params, SectorActivationManifest,
+    SectorClaim, State as MinerState,
+};
 use fil_actor_power::State as PowerState;
 use fil_actor_verifreg::{
     Claim, Method as VerifregMethod, RemoveExpiredClaimsParams, RemoveExpiredClaimsReturn,
@@ -27,18 +32,19 @@ use fil_actors_runtime::{
     DealWeight, DATACAP_TOKEN_ACTOR_ADDR, EPOCHS_IN_DAY, STORAGE_MARKET_ACTOR_ADDR,
     STORAGE_POWER_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR,
 };
-use vm_api::util::{apply_ok, get_state, DynBlockstore};
+use vm_api::trace::ExpectInvocation;
+use vm_api::util::{apply_code, apply_ok, get_state, DynBlockstore};
 use vm_api::VM;
 
 use crate::util::{
     advance_by_deadline_to_epoch, advance_by_deadline_to_epoch_while_proving,
     advance_by_deadline_to_index, advance_to_proving_deadline, assert_invariants, create_accounts,
     create_miner, cron_tick, datacap_extend_claim, datacap_get_balance, expect_invariants,
-    invariant_failure_patterns, market_add_balance, market_pending_deal_allocations,
-    market_publish_deal, miner_extend_sector_expiration2, miner_precommit_one_sector_v2,
-    miner_prove_sector, precommit_meta_data_from_deals, provider_settle_deal_payments,
-    sector_deadline, submit_windowed_post, verifreg_add_client, verifreg_add_verifier,
-    verifreg_extend_claim_terms, verifreg_remove_expired_allocations,
+    invariant_failure_patterns, make_piece_manifests_from_deal_ids, market_add_balance,
+    market_pending_deal_allocations, market_publish_deal, miner_extend_sector_expiration2,
+    miner_precommit_one_sector_v2, miner_prove_sector, precommit_meta_data_from_deals,
+    provider_settle_deal_payments, sector_deadline, submit_windowed_post, verifreg_add_client,
+    verifreg_add_verifier, verifreg_extend_claim_terms, verifreg_remove_expired_allocations,
 };
 
 /// Tests a scenario involving a verified deal from the built-in market, with associated
@@ -102,14 +108,20 @@ pub fn verified_claim_scenario_test(v: &dyn VM) {
         &miner_id,
         seal_proof,
         sector_number,
-        precommit_meta_data_from_deals(v, &deals, seal_proof),
+        precommit_meta_data_from_deals(v, &deals, seal_proof, false),
         true,
         deal_start + sector_term,
     );
 
     // Advance time to max seal duration and prove the sector
     advance_by_deadline_to_epoch(v, &miner_id, deal_start);
-    miner_prove_sector(v, &worker, &miner_id, sector_number);
+    miner_prove_sector(
+        v,
+        &worker,
+        &miner_id,
+        sector_number,
+        make_piece_manifests_from_deal_ids(v, deals.clone()),
+    );
     // Trigger cron to validate the prove commit
     cron_tick(v);
 
@@ -562,7 +574,7 @@ pub fn deal_passes_claim_fails_test(v: &dyn VM) {
         &miner_id,
         seal_proof,
         sector_number_a,
-        precommit_meta_data_from_deals(v, &[deal], seal_proof),
+        precommit_meta_data_from_deals(v, &[deal], seal_proof, false),
         true,
         sector_start + sector_term,
     );
@@ -573,15 +585,50 @@ pub fn deal_passes_claim_fails_test(v: &dyn VM) {
         &miner_id,
         seal_proof,
         sector_number_b,
-        precommit_meta_data_from_deals(v, &[bad_deal], seal_proof),
+        precommit_meta_data_from_deals(v, &[bad_deal], seal_proof, false),
         false,
         sector_start + sector_term,
     );
 
     // Advance time and prove the sector
     advance_by_deadline_to_epoch(v, &miner_id, sector_start);
-    miner_prove_sector(v, &worker, &miner_id, sector_number_a);
-    miner_prove_sector(v, &worker, &miner_id, sector_number_b);
+    // ProveCommit3 fails on sector b because allocation is expired
+    let failing_prove_commit_params = ProveCommitSectors3Params {
+        sector_activations: vec![
+            SectorActivationManifest {
+                sector_number: sector_number_b,
+                pieces: make_piece_manifests_from_deal_ids(v, vec![bad_deal]),
+            },
+            SectorActivationManifest {
+                sector_number: sector_number_a,
+                pieces: make_piece_manifests_from_deal_ids(v, vec![deal]),
+            },
+        ],
+        sector_proofs: vec![vec![].into(), vec![].into()],
+        aggregate_proof: RawBytes::default(),
+        aggregate_proof_type: None,
+        require_activation_success: true, //
+        require_notification_success: true,
+    };
+    apply_code(
+        v,
+        &worker,
+        &miner_id,
+        &TokenAmount::zero(),
+        fil_actor_miner::Method::ProveCommitSectors3 as u64,
+        Some(failing_prove_commit_params),
+        ExitCode::USR_ILLEGAL_ARGUMENT,
+    );
+    let worker_id = v.resolve_id_address(&worker).unwrap().id().unwrap();
+    ExpectInvocation {
+        from: worker_id,
+        to: miner_id,
+        method: fil_actor_miner::Method::ProveCommitSectors3 as u64,
+        exit_code: ExitCode::USR_ILLEGAL_ARGUMENT,
+        ..Default::default()
+    }
+    .matches(v.take_invocations().last().unwrap());
+
     cron_tick(v);
     v.set_epoch(v.epoch() + 1);
 

integration_tests/src/util/mod.rs

@@ -12,6 +12,7 @@ use fil_actor_reward::State as RewardState;
 use fil_actor_verifreg::{Claim, ClaimID, State as VerifregState};
 use fil_actors_runtime::cbor::serialize;
 use fil_actors_runtime::test_utils::make_piece_cid;
+use fil_actors_runtime::ActorError;
 use fil_actors_runtime::{
     parse_uint_key, runtime::Policy, MessageAccumulator, REWARD_ACTOR_ADDR,
     STORAGE_MARKET_ACTOR_ADDR, STORAGE_POWER_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR,
@@ -168,7 +169,20 @@ pub fn get_beneficiary(v: &dyn VM, from: &Address, m_addr: &Address) -> GetBenef
     .unwrap()
 }
 
+pub fn market_pending_deal_allocations_raw(
+    v: &dyn VM,
+    deals: &[DealID],
+) -> Result<Vec<AllocationID>, ActorError> {
+    let mut st: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap();
+    let bs = &DynBlockstore::wrap(v.blockstore());
+    st.get_pending_deal_allocation_ids(bs, deals)
+}
+
 pub fn market_pending_deal_allocations(v: &dyn VM, deals: &[DealID]) -> Vec<AllocationID> {
+    market_pending_deal_allocations_raw(v, deals).unwrap()
+}
+
+pub fn market_maybe_pending_deal_allocations(v: &dyn VM, deals: &[DealID]) -> Vec<AllocationID> {
     let mut st: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap();
     let bs = &DynBlockstore::wrap(v.blockstore());
     st.get_pending_deal_allocation_ids(bs, deals).unwrap()