itests almost there

actors/miner/src/ext.rs

@@ -95,9 +95,10 @@ pub mod market {
         pub unsealed_cids: Vec<Option<Cid>>,
     }
 
-    #[derive(Serialize_tuple, Deserialize_tuple, Clone)]
-    pub struct GetDealDataCommitmentParams {
-        pub deal_id: DealID,
+    #[derive(Serialize_tuple, Deserialize_tuple, Debug, Clone, Eq, PartialEq)]
+    #[serde(transparent)]
+    pub struct GetDealDataCommitmentParamsRef {
+        pub id: DealID,
     }
 
     #[derive(Serialize_tuple, Deserialize_tuple, Clone)]

actors/miner/src/lib.rs

@@ -4862,7 +4862,7 @@ fn get_deal_data_commitment(
     deserialize_block(extract_send_result(rt.send_simple(
         &STORAGE_MARKET_ACTOR_ADDR,
         ext::market::GET_DEAL_DATA_COMMITMENT,
-        IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentParams { deal_id: *deal_id })?,
+        IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentParamsRef { id: *deal_id })?,
         TokenAmount::zero(),
     ))?)
 }

actors/miner/tests/util.rs

@@ -2949,10 +2949,8 @@ pub fn expect_sector_event_with_market_call(
         rt.expect_send_simple(
             STORAGE_MARKET_ACTOR_ADDR,
             MarketMethod::GetDealDataCommitmentExported as u64,
-            IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentParams {
-                deal_id: *deal_id,
-            })
-            .unwrap(),
+            IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentParams { id: *deal_id })
+                .unwrap(),
             TokenAmount::zero(),
             IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentReturn {
                 data: make_unsealed_cid("test verified deal".as_bytes()),

integration_tests/src/expects.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use cid::Cid;
 use frc46_token::receiver::{FRC46TokenReceived, FRC46_TOKEN_TYPE};
 use frc46_token::token::types::BurnParams;
@@ -51,7 +52,13 @@ impl Expect {
         sector_expiry: ChainEpoch,
         sector_type: RegisteredSealProof,
         compute_cid: bool,
+        client_id: &ActorID,
     ) -> ExpectInvocation {
+        let events: Vec<EmittedEvent> = deals
+            .iter()
+            .map(|deal_id| Expect::build_market_event("deal-activated", &deal_id, client_id, &from))
+            .collect();
+
         let params = IpldBlock::serialize_cbor(&BatchActivateDealsParams {
             sectors: vec![SectorDeals {
                 sector_number,
@@ -69,14 +76,21 @@ impl Expect {
             params: Some(params),
             value: Some(TokenAmount::zero()),
             subinvocs: Some(vec![]),
+            events,
             ..Default::default()
         }
     }
     pub fn market_sectors_terminate(
         from: ActorID,
         epoch: ChainEpoch,
         sectors: Vec<SectorNumber>,
+       deal_clients: Vec<(DealID, ActorID)>,
     ) -> ExpectInvocation {
+        let events: Vec<EmittedEvent> = deal_clients
+            .iter()
+            .map(|(deal_id,client)| Expect::build_market_event("deal-terminated", &deal_id, &client, &from))
+            .collect();
+
         let bf = BitField::try_from_bits(sectors).unwrap();
         let params =
             IpldBlock::serialize_cbor(&OnMinerSectorsTerminateParams { epoch, sectors: bf })
@@ -88,6 +102,7 @@ impl Expect {
             params: Some(params),
             value: Some(TokenAmount::zero()),
             subinvocs: Some(vec![]),
+            events,
             ..Default::default()
         }
     }

integration_tests/src/tests/extend_sectors_test.rs

@@ -1,11 +1,11 @@
+use cid::Cid;
 use fvm_ipld_bitfield::BitField;
 use fvm_shared::address::Address;
 use fvm_shared::bigint::Zero;
 use fvm_shared::clock::ChainEpoch;
 use fvm_shared::econ::TokenAmount;
-use fvm_shared::piece::PaddedPieceSize;
+use fvm_shared::piece::{PaddedPieceSize, PieceInfo};
 use fvm_shared::sector::{RegisteredSealProof, SectorNumber, StoragePower};
-
 use export_macro::vm_test;
 use fil_actor_miner::{
     max_prove_commit_duration, power_for_sector, ExpirationExtension, ExpirationExtension2,
@@ -15,21 +15,14 @@ use fil_actor_miner::{
 };
 use fil_actor_verifreg::Method as VerifregMethod;
 use fil_actors_runtime::runtime::Policy;
-use fil_actors_runtime::test_utils::make_sealed_cid;
-use fil_actors_runtime::{DealWeight, EPOCHS_IN_DAY, VERIFIED_REGISTRY_ACTOR_ADDR};
+use fil_actors_runtime::test_utils::{make_piece_cid, make_sealed_cid};
+use fil_actors_runtime::{DealWeight, EPOCHS_IN_DAY, STORAGE_MARKET_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR};
 use vm_api::trace::ExpectInvocation;
 use vm_api::util::{apply_ok, get_state, mutate_state, DynBlockstore};
 use vm_api::VM;
 
 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, precommit_meta_data_from_deals, sector_deadline, submit_windowed_post,
-    verifreg_add_client, verifreg_add_verifier, PrecommitMetadata,
-};
+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, precommit_meta_data_from_deals, sector_deadline, submit_windowed_post, verifreg_add_client, verifreg_add_verifier, PrecommitMetadata, override_compute_unsealed_sector_cid};
 
 #[allow(clippy::too_many_arguments)]
 pub fn extend(
@@ -520,12 +513,17 @@ pub fn extend_sector_up_to_max_relative_extension_test(v: &dyn VM) {
 
 #[vm_test]
 pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
+    override_compute_unsealed_sector_cid(v);
+
     let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000));
     let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1;
     let (owner, worker, verifier, verified_client) = (addrs[0], addrs[0], addrs[1], addrs[2]);
     let worker_id = worker.id().unwrap();
     let sector_number: SectorNumber = 100;
     let policy = Policy::default();
+    let deal_label = "deal1".to_string();
+    let piece_cid = make_piece_cid(deal_label.as_bytes());
+    let piece_size =  PaddedPieceSize(32u64 << 30);
 
     // create miner
     let miner_addr = create_miner(
@@ -555,7 +553,6 @@ pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
         true,
         expiration,
     );
-
     // 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);
@@ -615,8 +612,8 @@ pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
         &worker,
         &verified_client,
         &miner_addr,
-        "deal1".to_string(),
-        PaddedPieceSize(32u64 << 30),
+        deal_label,
+       piece_size,
         true,
         deal_start,
         340 * EPOCHS_IN_DAY,
@@ -651,6 +648,11 @@ pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
     assert_eq!(vec![sector_number], bf_all(updated_sectors));
 
     let old_power = power_for_sector(seal_proof.sector_size().unwrap(), &initial_sector_info);
+
+    let pieces: Vec<(Cid, PaddedPieceSize)> = vec![(piece_cid, piece_size)];
+    let pis: Vec<PieceInfo> = vec![PieceInfo { cid: piece_cid, size: piece_size }];
+    let unsealed_cid = v.primitives().compute_unsealed_sector_cid(seal_proof, &pis).unwrap();
+
     // check for the expected subcalls
     ExpectInvocation {
         from: worker_id,
@@ -664,11 +666,24 @@ pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
                 initial_sector_info.expiration,
                 initial_sector_info.seal_proof,
                 true,
+                &verified_client.id().unwrap(),
             ),
             ExpectInvocation {
                 from: miner_id,
                 to: VERIFIED_REGISTRY_ACTOR_ADDR,
                 method: VerifregMethod::ClaimAllocations as u64,
+                events: vec![Expect::build_verifreg_event(
+                    "claim",
+                    &claim_id,
+                    &verified_client.id().unwrap(),
+                    &miner_id,
+                )],
+                ..Default::default()
+            },
+            ExpectInvocation {
+                from: miner_id,
+                to: STORAGE_MARKET_ACTOR_ADDR,
+                method: fil_actor_market::Method::GetDealDataCommitmentExported as u64,
                 ..Default::default()
             },
             Expect::reward_this_epoch(miner_id),
@@ -679,6 +694,7 @@ pub fn extend_updated_sector_with_claims_test(v: &dyn VM) {
                 PowerPair { raw: StoragePower::zero(), qa: 9 * old_power.qa },
             ),
         ]),
+        events: vec![Expect::build_sector_activation_event("sector-updated", &miner_id, &sector_number, &unsealed_cid, &pieces)],
         ..Default::default()
     }
     .matches(v.take_invocations().last().unwrap());

integration_tests/src/tests/prove_commit2_test.rs

@@ -34,33 +34,12 @@ use vm_api::VM;
 
 use crate::deals::{DealBatcher, DealOptions};
 use crate::expects::Expect;
-use crate::util::{
-    advance_by_deadline_to_epoch, create_accounts, create_miner, datacap_create_allocations,
-    market_add_balance, market_list_deals, market_list_sectors_deals, precommit_sectors_v2,
-    sector_info, verifreg_add_client, verifreg_add_verifier, verifreg_list_claims,
-    PrecommitMetadata,
-};
+use crate::util::{advance_by_deadline_to_epoch, create_accounts, create_miner, datacap_create_allocations, market_add_balance, market_list_deals, market_list_sectors_deals, precommit_sectors_v2, sector_info, verifreg_add_client, verifreg_add_verifier, verifreg_list_claims, PrecommitMetadata, override_compute_unsealed_sector_cid};
 
 #[vm_test]
 pub fn prove_commit_sectors2_test(v: &dyn VM) {
     // Expectations depend on the correct unsealed CID for empty sector.
-    // TODO: move this code somewhere more accessible.
-    // This change was made during a long rebase during which structural change was not practical.
-    v.mut_primitives().override_compute_unsealed_sector_cid(
-        |proof_type: RegisteredSealProof, pis: &[PieceInfo]| {
-            if pis.is_empty() {
-                return Ok(CompactCommD::empty().get_cid(proof_type).unwrap());
-            }
-            let mut buf: Vec<u8> = Vec::new();
-            let ptv: i64 = proof_type.into();
-            buf.extend(ptv.encode_var_vec());
-            for p in pis {
-                buf.extend(&p.cid.to_bytes());
-                buf.extend(p.size.0.encode_var_vec())
-            }
-            Ok(make_piece_cid(&buf))
-        },
-    );
+    override_compute_unsealed_sector_cid(v);
     let policy = Policy::default();
     let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000));
     let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1;

integration_tests/src/tests/replica_update2_test.rs

@@ -37,33 +37,13 @@ use vm_api::VM;
 
 use crate::deals::{DealBatcher, DealOptions};
 use crate::expects::Expect;
-use crate::util::{
-    advance_by_deadline_to_epoch, advance_by_deadline_to_index, advance_to_proving_deadline,
-    create_accounts, create_miner, datacap_create_allocations, market_add_balance,
-    market_list_deals, market_list_sectors_deals, precommit_sectors_v2, sector_info,
-    submit_windowed_post, verifreg_add_client, verifreg_add_verifier, verifreg_list_claims,
-    PrecommitMetadata,
-};
+use crate::util::{advance_by_deadline_to_epoch, advance_by_deadline_to_index, advance_to_proving_deadline, create_accounts, create_miner, datacap_create_allocations, market_add_balance, market_list_deals, market_list_sectors_deals, precommit_sectors_v2, sector_info, submit_windowed_post, verifreg_add_client, verifreg_add_verifier, verifreg_list_claims, PrecommitMetadata, override_compute_unsealed_sector_cid};
 
 #[vm_test]
 pub fn prove_replica_update2_test(v: &dyn VM) {
     // TODO: move this code somewhere more accessible.
     // This change was made during a long rebase during which structural change was not practical.
-    v.mut_primitives().override_compute_unsealed_sector_cid(
-        |proof_type: RegisteredSealProof, pis: &[PieceInfo]| {
-            if pis.is_empty() {
-                return Ok(CompactCommD::empty().get_cid(proof_type).unwrap());
-            }
-            let mut buf: Vec<u8> = Vec::new();
-            let ptv: i64 = proof_type.into();
-            buf.extend(ptv.encode_var_vec());
-            for p in pis {
-                buf.extend(&p.cid.to_bytes());
-                buf.extend(p.size.0.encode_var_vec())
-            }
-            Ok(make_piece_cid(&buf))
-        },
-    );
+    override_compute_unsealed_sector_cid(v);
 
     let policy = Policy::default();
     let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000));

integration_tests/src/tests/replica_update_test.rs

@@ -1,3 +1,4 @@
+use cid::Cid;
 use fvm_ipld_bitfield::BitField;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::Address;
@@ -6,14 +7,15 @@ use fvm_shared::clock::ChainEpoch;
 use fvm_shared::deal::DealID;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
-use fvm_shared::piece::PaddedPieceSize;
+use fvm_shared::piece::{PaddedPieceSize, PieceInfo};
 use fvm_shared::sector::SectorSize;
 use fvm_shared::sector::StoragePower;
 use fvm_shared::sector::{RegisteredSealProof, SectorNumber};
 
 use export_macro::vm_test;
 use fil_actor_cron::Method as CronMethod;
 use fil_actor_market::Method as MarketMethod;
+use fil_actor_market::State as MarketState;
 use fil_actor_miner::{
     power_for_sector, DisputeWindowedPoStParams, ExpirationExtension, ExtendSectorExpirationParams,
     Method as MinerMethod, PowerPair, ProveCommitSectorParams, ProveReplicaUpdatesParams,
@@ -33,14 +35,7 @@ use vm_api::VM;
 
 use crate::expects::Expect;
 
-use crate::util::{
-    advance_by_deadline_to_epoch, advance_by_deadline_to_index, advance_to_proving_deadline,
-    assert_invariants, bf_all, check_sector_active, check_sector_faulty, create_accounts,
-    create_miner, deadline_state, declare_recovery, expect_invariants, get_deal_weights,
-    get_network_stats, invariant_failure_patterns, make_bitfield, market_publish_deal,
-    miner_balance, miner_power, precommit_sectors_v2, prove_commit_sectors, sector_info,
-    submit_invalid_post, submit_windowed_post, verifreg_add_client, verifreg_add_verifier,
-};
+use crate::util::{advance_by_deadline_to_epoch, advance_by_deadline_to_index, advance_to_proving_deadline, assert_invariants, bf_all, check_sector_active, check_sector_faulty, create_accounts, create_miner, deadline_state, declare_recovery, expect_invariants, get_deal_weights, get_network_stats, invariant_failure_patterns, make_bitfield, market_publish_deal, miner_balance, miner_power, 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};
 
 #[vm_test]
 pub fn replica_update_full_path_success_test(v: &dyn VM) {
@@ -973,6 +968,7 @@ pub fn deal_included_in_multiple_sectors_failure_test(v: &dyn VM) {
 
 #[vm_test]
 pub fn replica_update_verified_deal_test(v: &dyn VM) {
+    override_compute_unsealed_sector_cid(v);
     let addrs = create_accounts(v, 3, &TokenAmount::from_whole(100_000));
     let (worker, owner, client, verifier) = (addrs[0], addrs[0], addrs[1], addrs[2]);
     let worker_id = worker.id().unwrap();
@@ -1010,6 +1006,10 @@ pub fn replica_update_verified_deal_test(v: &dyn VM) {
         old_sector_info.expiration - v.epoch() - policy.market_default_allocation_term_buffer,
     );
 
+    let st: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap();
+    let store = DynBlockstore::wrap(v.blockstore());
+    let proposal = st.get_proposal(&store, deal_ids[0]).unwrap();
+
     // replica update
     let new_sealed_cid = make_sealed_cid(b"replica1");
 
@@ -1034,7 +1034,15 @@ pub fn replica_update_verified_deal_test(v: &dyn VM) {
     .unwrap();
     assert_eq!(vec![100], bf_all(updated_sectors));
 
+    let claim_id = 1_u64;
+    let claim_event =
+        Expect::build_verifreg_event("claim", &claim_id, &client.id().unwrap(), &maddr.id().unwrap());
     let old_power = power_for_sector(seal_proof.sector_size().unwrap(), &old_sector_info);
+
+    let pieces: Vec<(Cid, PaddedPieceSize)> = vec![(proposal.piece_cid, proposal.piece_size)];
+    let pis: Vec<PieceInfo> = vec![PieceInfo { cid:proposal.piece_cid, size: proposal.piece_size}];
+    let unsealed_cid = v.primitives().compute_unsealed_sector_cid(seal_proof, &pis).unwrap();
+
     // check for the expected subcalls
     ExpectInvocation {
         from: worker_id,
@@ -1048,11 +1056,19 @@ pub fn replica_update_verified_deal_test(v: &dyn VM) {
                 old_sector_info.expiration,
                 old_sector_info.seal_proof,
                 true,
+                &client.id().unwrap(),
             ),
             ExpectInvocation {
                 from: miner_id,
                 to: VERIFIED_REGISTRY_ACTOR_ADDR,
                 method: VerifregMethod::ClaimAllocations as u64,
+                events:vec![claim_event],
+                ..Default::default()
+            },
+            ExpectInvocation {
+                from: miner_id,
+                to: STORAGE_MARKET_ACTOR_ADDR,
+                method: fil_actor_market::Method::GetDealDataCommitmentExported as u64,
                 ..Default::default()
             },
             Expect::reward_this_epoch(miner_id),
@@ -1064,6 +1080,7 @@ pub fn replica_update_verified_deal_test(v: &dyn VM) {
                 PowerPair { raw: StoragePower::zero(), qa: 9 * old_power.qa },
             ),
         ]),
+        events: vec![Expect::build_sector_activation_event("sector-updated", &miner_id, &sector_number, &unsealed_cid, &pieces)],
         ..Default::default()
     }
     .matches(v.take_invocations().last().unwrap());