Fix int test and deps

Author: NemanjaLu92

Cargo.lock

@@ -116,16 +116,20 @@ libipld-core = { version = "0.13.1", features = ["serde-codec"] }
 integer-encoding = { version = "3.0.3", default-features = false }
 
 # helix-onchain
-fvm_actor_utils = "9.0.0"
-frc42_dispatch = "5.0.0"
-frc46_token = "9.0.0"
+# fvm_actor_utils = "10.0.0"
+# frc42_dispatch = "6.0.0"
+# frc46_token = "10.0.0"
+
+fvm_actor_utils = { git = "https://github.com/helix-onchain/filecoin", branch = "rvagg/nv23" }
+frc42_dispatch = { git = "https://github.com/helix-onchain/filecoin", branch = "rvagg/nv23" }
+frc46_token = { git = "https://github.com/helix-onchain/filecoin", branch = "rvagg/nv23" }
 
 # FVM
-fvm_sdk = "~4.0"
-fvm_shared = "~4.0"
+fvm_sdk = "4.3.0"
+fvm_shared = "4.3.0"
 fvm_ipld_encoding = "0.4.0"
 fvm_ipld_blockstore = "0.2.0"
-fvm_ipld_hamt = "0.8.0"
+fvm_ipld_hamt = "0.9.0"
 fvm_ipld_kamt = "0.3.0"
 fvm_ipld_amt = { version = "0.6.2" }
 fvm_ipld_bitfield = "0.6.0"

Cargo.toml

@@ -84,19 +84,19 @@ fn zero_commd(seal_proof: RegisteredSealProof) -> Result<Cid, ActorError> {
     let i = match seal_proof {
         RegisteredSealProof::StackedDRG2KiBV1P1
         | RegisteredSealProof::StackedDRG2KiBV1P1_Feat_SyntheticPoRep
-        | RegisteredSealProof::StackedDRG2KiBV1P1_Feat_NiPoRep => 0,
+        | RegisteredSealProof::StackedDRG2KiBV1P2_Feat_NiPoRep => 0,
         RegisteredSealProof::StackedDRG512MiBV1P1
         | RegisteredSealProof::StackedDRG512MiBV1P1_Feat_SyntheticPoRep
-        | RegisteredSealProof::StackedDRG512MiBV1P1_Feat_NiPoRep => 1,
+        | RegisteredSealProof::StackedDRG512MiBV1P2_Feat_NiPoRep => 1,
         RegisteredSealProof::StackedDRG8MiBV1P1
         | RegisteredSealProof::StackedDRG8MiBV1P1_Feat_SyntheticPoRep
-        | RegisteredSealProof::StackedDRG8MiBV1P1_Feat_NiPoRep => 2,
+        | RegisteredSealProof::StackedDRG8MiBV1P2_Feat_NiPoRep => 2,
         RegisteredSealProof::StackedDRG32GiBV1P1
         | RegisteredSealProof::StackedDRG32GiBV1P1_Feat_SyntheticPoRep
-        | RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep => 3,
+        | RegisteredSealProof::StackedDRG32GiBV1P2_Feat_NiPoRep => 3,
         RegisteredSealProof::StackedDRG64GiBV1P1
         | RegisteredSealProof::StackedDRG64GiBV1P1_Feat_SyntheticPoRep
-        | RegisteredSealProof::StackedDRG64GiBV1P1_Feat_NiPoRep => 4,
+        | RegisteredSealProof::StackedDRG64GiBV1P2_Feat_NiPoRep => 4,
         _ => {
             return Err(actor_error!(illegal_argument, "unknown SealProof"));
         }

actors/miner/src/commd.rs

@@ -1,17 +1,11 @@
-use fil_actors_runtime::{
-    actor_error, cbor::serialize, test_utils::expect_empty, ActorError, BURNT_FUNDS_ACTOR_ADDR,
-};
+use fil_actors_runtime::cbor::serialize;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_shared::{
-    clock::ChainEpoch,
-    commcid::cid_to_replica_commitment_v1,
-    error::ExitCode,
-    randomness::Randomness,
-    sector::{AggregateSealVerifyInfo, SealVerifyInfo},
-    METHOD_SEND,
+    clock::ChainEpoch, commcid::cid_to_replica_commitment_v1, error::ExitCode,
+    randomness::Randomness, sector::AggregateSealVerifyInfo,
 };
 
-use fil_actor_miner::{aggregate_prove_commit_network_fee, Actor, CompactCommD, Method};
+use fil_actor_miner::{Actor, CompactCommD, Method};
 use log::info;
 use util::*;
 

actors/miner/tests/prove_commit_niporep.rs

@@ -564,7 +564,7 @@ impl ActorHarness {
 
         ProveCommitSectorsNIParams {
             sectors,
-            seal_proof_type: RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep,
+            seal_proof_type: RegisteredSealProof::StackedDRG32GiBV1P2_Feat_NiPoRep,
             aggregate_proof: make_proof(0),
             aggregate_proof_type: RegisteredAggregateProof::SnarkPackV2,
             proving_deadline: 0,

actors/miner/tests/util.rs

@@ -348,7 +348,6 @@ pub fn prove_commit_sectors2_test(v: &dyn VM) {
     // Checks on sector state.
     let sectors =
         manifests.iter().map(|m| sector_info(v, &maddr, m.sector_number)).collect::<Vec<_>>();
-    info!("sectors: {:#?}", sectors);
     for sector in &sectors {
         assert_eq!(activation_epoch, sector.activation);
         assert_eq!(activation_epoch, sector.power_base_epoch);

integration_tests/src/tests/prove_commit3_test.rs

@@ -1,10 +1,9 @@
-use fil_actors_runtime::EPOCHS_IN_YEAR;
+use fil_actors_runtime::runtime::Policy;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::bigint::BigInt;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::sector::{RegisteredAggregateProof, RegisteredSealProof, SectorNumber};
-use log::info;
 use num_traits::Zero;
 
 use export_macro::vm_test;
@@ -19,107 +18,12 @@ use crate::util::{
     create_accounts, create_miner, override_compute_unsealed_sector_cid, sector_info,
 };
 
-#[vm_test]
-pub fn prove_commit_sectors_niporep_test(v: &dyn VM) {
-    // Expectations depend on the correct unsealed CID for empty sector.
-    override_compute_unsealed_sector_cid(v);
-    let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000));
-    let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep;
-    let (owner, worker, _, _) = (addrs[0], addrs[0], addrs[1], addrs[2]);
-    let worker_id = worker.id().unwrap();
-    let (maddr, _) = create_miner(
-        v,
-        &owner,
-        &worker,
-        seal_proof.registered_window_post_proof().unwrap(),
-        &TokenAmount::from_whole(8_000),
-    );
-    let miner_id = maddr.id().unwrap();
-
-    // Onboard a batch of sectors
-    let expiration = v.epoch() + 2 * EPOCHS_IN_YEAR;
-    let seal_rand_epoch = v.epoch() - 1;
-    let first_sector_number: SectorNumber = 100;
-    let manifests = vec![
-        first_sector_number,
-        first_sector_number + 1,
-        first_sector_number + 2,
-        first_sector_number + 3,
-        first_sector_number + 4,
-    ];
-
-    let sectors_info: Vec<SectorNIActivationInfo> = manifests
-        .iter()
-        .map(|sector_number| SectorNIActivationInfo {
-            sealing_number: *sector_number,
-            sealer_id: miner_id,
-            sector_number: *sector_number,
-            sealed_cid: make_sealed_cid(format!("sn: {}", sector_number).as_bytes()),
-            seal_rand_epoch,
-            expiration,
-        })
-        .collect();
-
-    // Prove-commit NI-PoRep
-    let proofs = vec![RawBytes::new(vec![1, 2, 3, 4]); manifests.len()];
-    let params = ProveCommitSectorsNIParams {
-        sectors: sectors_info.clone(),
-        seal_proof_type: RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep,
-        sector_proofs: proofs,
-        aggregate_proof: RawBytes::default(),
-        aggregate_proof_type: None,
-        require_activation_success: true,
-    };
-
-    let activation_epoch = v.epoch() + EPOCHS_IN_YEAR / 2;
-    v.set_epoch(activation_epoch);
-
-    apply_ok(
-        v,
-        &worker,
-        &maddr,
-        &TokenAmount::zero(),
-        MinerMethod::ProveCommitSectorsNI as u64,
-        Some(params.clone()),
-    );
-
-    ExpectInvocation {
-        from: worker_id,
-        to: maddr,
-        method: MinerMethod::ProveCommitSectorsNI as u64,
-        params: Some(IpldBlock::serialize_cbor(&params).unwrap()),
-        subinvocs: None,
-        events: Vec::new(),
-        ..Default::default()
-    }
-    .matches(v.take_invocations().last().unwrap());
-
-    // Checks on sector state.
-    let sectors = manifests
-        .iter()
-        .map(|sector_number| sector_info(v, &maddr, *sector_number))
-        .collect::<Vec<_>>();
-    info!("sectors: {:#?}", sectors);
-    for (on_chain_sector, input_sector) in sectors.iter().zip(sectors_info) {
-        assert_eq!(input_sector.sector_number, on_chain_sector.sector_number);
-        assert_eq!(params.seal_proof_type, on_chain_sector.seal_proof);
-        assert_eq!(input_sector.sealed_cid, on_chain_sector.sealed_cid);
-        assert!(on_chain_sector.deprecated_deal_ids.is_empty());
-        assert_eq!(activation_epoch, on_chain_sector.activation);
-        assert_eq!(input_sector.expiration, on_chain_sector.expiration);
-        assert_eq!(BigInt::zero(), on_chain_sector.deal_weight);
-        assert_eq!(BigInt::zero(), on_chain_sector.verified_deal_weight);
-        assert_eq!(activation_epoch, on_chain_sector.power_base_epoch);
-        assert!(on_chain_sector.flags.contains(SectorOnChainInfoFlags::SIMPLE_QA_POWER));
-    }
-}
-
 #[vm_test]
 pub fn prove_commit_sectors_aggregate_niporep_test(v: &dyn VM) {
     // Expectations depend on the correct unsealed CID for empty sector.
     override_compute_unsealed_sector_cid(v);
     let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000));
-    let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep;
+    let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P2_Feat_NiPoRep;
     let (owner, worker, _, _) = (addrs[0], addrs[0], addrs[1], addrs[2]);
     let worker_id = worker.id().unwrap();
     let (maddr, _) = create_miner(
@@ -130,10 +34,11 @@ pub fn prove_commit_sectors_aggregate_niporep_test(v: &dyn VM) {
         &TokenAmount::from_whole(8_000),
     );
     let miner_id = maddr.id().unwrap();
+    let policy = Policy::default();
 
     // Onboard a batch of sectors
-    let expiration = v.epoch() + 2 * EPOCHS_IN_YEAR;
-    let seal_rand_epoch = v.epoch() - 1;
+    let expiration = v.epoch() + policy.min_sector_expiration;
+    let seal_rand_epoch = v.epoch();
     let first_sector_number: SectorNumber = 100;
     let manifests = vec![
         first_sector_number,
@@ -159,14 +64,14 @@ pub fn prove_commit_sectors_aggregate_niporep_test(v: &dyn VM) {
     let aggregate_proof = RawBytes::new(vec![1, 2, 3, 4]);
     let params = ProveCommitSectorsNIParams {
         sectors: sectors_info.clone(),
-        seal_proof_type: RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep,
-        sector_proofs: Vec::new(),
+        seal_proof_type: RegisteredSealProof::StackedDRG32GiBV1P2_Feat_NiPoRep,
         aggregate_proof,
-        aggregate_proof_type: Some(RegisteredAggregateProof::SnarkPackV2),
+        aggregate_proof_type: RegisteredAggregateProof::SnarkPackV2,
+        proving_deadline: 0,
         require_activation_success: true,
     };
 
-    let activation_epoch = v.epoch() + EPOCHS_IN_YEAR / 2;
+    let activation_epoch = v.epoch() + policy.max_prove_commit_ni_randomness_lookback / 2;
     v.set_epoch(activation_epoch);
 
     apply_ok(
@@ -184,7 +89,7 @@ pub fn prove_commit_sectors_aggregate_niporep_test(v: &dyn VM) {
         method: MinerMethod::ProveCommitSectorsNI as u64,
         params: Some(IpldBlock::serialize_cbor(&params).unwrap()),
         subinvocs: None,
-        events: Vec::new(),
+        events: None,
         ..Default::default()
     }
     .matches(v.take_invocations().last().unwrap());
@@ -194,7 +99,7 @@ pub fn prove_commit_sectors_aggregate_niporep_test(v: &dyn VM) {
         .iter()
         .map(|sector_number| sector_info(v, &maddr, *sector_number))
         .collect::<Vec<_>>();
-    info!("sectors: {:#?}", sectors);
+
     for (on_chain_sector, input_sector) in sectors.iter().zip(sectors_info) {
         assert_eq!(input_sector.sector_number, on_chain_sector.sector_number);
         assert_eq!(params.seal_proof_type, on_chain_sector.seal_proof);

integration_tests/src/tests/prove_commit_niporep_test.rs

@@ -454,7 +454,7 @@ impl ProofSet {
             proofs[i64::from(RegisteredSealProof::StackedDRG64GiBV1P1) as usize] = true;
             proofs[i64::from(RegisteredSealProof::StackedDRG64GiBV1P1_Feat_SyntheticPoRep)
                 as usize] = true;
-            proofs[i64::from(RegisteredSealProof::StackedDRG64GiBV1P1_Feat_NiPoRep) as usize] =
+            proofs[i64::from(RegisteredSealProof::StackedDRG64GiBV1P2_Feat_NiPoRep) as usize] =
                 true;
         }
         ProofSet(proofs)
@@ -464,25 +464,25 @@ impl ProofSet {
         let mut proofs = vec![false; REGISTERED_SEAL_PROOF_VARIANTS];
         #[cfg(feature = "sector-2k")]
         {
-            proofs[i64::from(RegisteredSealProof::StackedDRG2KiBV1P1_Feat_NiPoRep) as usize] = true;
+            proofs[i64::from(RegisteredSealProof::StackedDRG2KiBV1P2_Feat_NiPoRep) as usize] = true;
         }
         #[cfg(feature = "sector-8m")]
         {
-            proofs[i64::from(RegisteredSealProof::StackedDRG8MiBV1P1_Feat_NiPoRep) as usize] = true;
+            proofs[i64::from(RegisteredSealProof::StackedDRG8MiBV1P2_Feat_NiPoRep) as usize] = true;
         }
         #[cfg(feature = "sector-512m")]
         {
-            proofs[i64::from(RegisteredSealProof::StackedDRG512MiBV1P1_Feat_NiPoRep) as usize] =
+            proofs[i64::from(RegisteredSealProof::StackedDRG512MiBV1P2_Feat_NiPoRep) as usize] =
                 true;
         }
         #[cfg(feature = "sector-32g")]
         {
-            proofs[i64::from(RegisteredSealProof::StackedDRG32GiBV1P1_Feat_NiPoRep) as usize] =
+            proofs[i64::from(RegisteredSealProof::StackedDRG32GiBV1P2_Feat_NiPoRep) as usize] =
                 true;
         }
         #[cfg(feature = "sector-64g")]
         {
-            proofs[i64::from(RegisteredSealProof::StackedDRG64GiBV1P1_Feat_NiPoRep) as usize] =
+            proofs[i64::from(RegisteredSealProof::StackedDRG64GiBV1P2_Feat_NiPoRep) as usize] =
                 true;
         }
         ProofSet(proofs)

runtime/src/runtime/policy.rs

@@ -1,17 +1,8 @@
-use fil_actors_integration_tests::tests::{
-    prove_commit_sectors_aggregate_niporep_test, prove_commit_sectors_niporep_test,
-};
+use fil_actors_integration_tests::tests::prove_commit_sectors_aggregate_niporep_test;
 use fil_actors_runtime::test_blockstores::MemoryBlockstore;
 use test_vm::TestVM;
 
-#[test_log::test]
-fn prove_commit_sectors_niporep() {
-    let store = MemoryBlockstore::new();
-    let v = TestVM::new_with_singletons(store);
-    prove_commit_sectors_niporep_test(&v);
-}
-
-#[test_log::test]
+#[test]
 fn prove_commit_sectors_aggregate_niporep() {
     let store = MemoryBlockstore::new();
     let v = TestVM::new_with_singletons(store);