Add aggregate proof integration test

Author: NemanjaLu92

integration_tests/src/tests/prove_commit_niporep_test.rs

@@ -3,7 +3,7 @@ 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::{RegisteredSealProof, SectorNumber};
+use fvm_shared::sector::{RegisteredAggregateProof, RegisteredSealProof, SectorNumber};
 use log::info;
 use num_traits::Zero;
 
@@ -113,3 +113,98 @@ pub fn prove_commit_sectors_niporep_test(v: &dyn VM) {
         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 (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 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(),
+        aggregate_proof,
+        aggregate_proof_type: Some(RegisteredAggregateProof::SnarkPackV2),
+        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));
+    }
+}

test_vm/tests/suite/prove_commit_niporep_test.rs

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