extract policy out of VM trait

state/src/check.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 
 use anyhow::bail;
-use bimap::BiBTreeMap;
 use cid::Cid;
 use fil_actor_account::State as AccountState;
 use fil_actor_cron::State as CronState;
@@ -144,7 +143,7 @@ pub fn check_state_invariants<BS: Blockstore>(
         }
         total_fil += &actor.balance;
 
-        match manifest.get_by_left(&actor.code) {
+        match manifest.get(&actor.code) {
             Some(Type::System) => (),
             Some(Type::Init) => {
                 let state = get_state!(tree, actor, InitState);

test_vm/src/lib.rs

@@ -1,6 +1,5 @@
 use crate::fakes::FakePrimitives;
 use anyhow::anyhow;
-use bimap::BiBTreeMap;
 use cid::multihash::Code;
 use cid::Cid;
 use fil_actor_account::{Actor as AccountActor, State as AccountState};
@@ -66,7 +65,7 @@ use regex::Regex;
 use serde::de::DeserializeOwned;
 use serde::{ser, Serialize};
 use std::cell::{RefCell, RefMut};
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::ops::Add;
 use trace::InvocationTrace;
 
@@ -257,6 +256,30 @@ where
     fn primitives(&self) -> &dyn Primitives {
         &self.primitives
     }
+
+    fn actor_manifest(&self) -> BTreeMap<Cid, Type> {
+        let actors = Hamt::<&'bs BS, ActorState, BytesKey, Sha256>::load(
+            &self.state_root.borrow(),
+            self.store,
+        )
+        .unwrap();
+        let mut manifest = BTreeMap::new();
+        actors
+            .for_each(|_, actor| {
+                manifest.insert(actor.code, ACTOR_TYPES.get(&actor.code).unwrap().to_owned());
+                Ok(())
+            })
+            .unwrap();
+        manifest
+    }
+
+    fn state_root(&self) -> Cid {
+        *self.state_root.borrow()
+    }
+
+    fn circulating_supply(&self) -> TokenAmount {
+        self.total_fil.clone()
+    }
 }
 
 impl<'bs, BS> TestVM<'bs, BS>
@@ -519,34 +542,6 @@ where
         })?;
         Ok(total)
     }
-
-    fn actor_manifest(&self) -> BiBTreeMap<Cid, Type> {
-        let actors = Hamt::<&'bs BS, ActorState, BytesKey, Sha256>::load(
-            &self.state_root.borrow(),
-            self.store,
-        )
-        .unwrap();
-        let mut manifest = BiBTreeMap::new();
-        actors
-            .for_each(|_, actor| {
-                manifest.insert(actor.code, ACTOR_TYPES.get(&actor.code).unwrap().to_owned());
-                Ok(())
-            })
-            .unwrap();
-        manifest
-    }
-
-    fn policy(&self) -> Policy {
-        Policy::default()
-    }
-
-    fn state_root(&self) -> Cid {
-        *self.state_root.borrow()
-    }
-
-    fn total_fil(&self) -> TokenAmount {
-        self.total_fil.clone()
-    }
 }
 
 #[derive(Clone)]

test_vm/src/util/mod.rs

@@ -793,12 +793,12 @@ pub fn check_invariants(vm: &dyn VM, policy: &Policy) -> anyhow::Result<MessageA
     )
 }
 
-pub fn assert_invariants(vm: &dyn VM, policy: &Policy) {
-    check_invariants(vm, policy).unwrap().assert_empty()
+pub fn assert_invariants(v: &dyn VM, policy: &Policy) {
+    check_invariants(v, policy).unwrap().assert_empty()
 }
 
-pub fn expect_invariants(vm: &dyn VM, policy: &Policy, expected_patterns: &[Regex]) {
-    check_invariants(vm, policy).unwrap().assert_expected(expected_patterns)
+pub fn expect_invariants(v: &dyn VM, policy: &Policy, expected_patterns: &[Regex]) {
+    check_invariants(v, policy).unwrap().assert_expected(expected_patterns)
 }
 
 pub fn get_network_stats(vm: &dyn VM) -> NetworkStats {

test_vm/tests/batch_onboarding.rs

@@ -6,6 +6,7 @@ use fil_actors_runtime::runtime::policy::policy_constants::PRE_COMMIT_CHALLENGE_
 use fil_actors_runtime::runtime::policy_constants::{
     MAX_AGGREGATED_SECTORS, PRE_COMMIT_SECTOR_BATCH_MAX_SIZE,
 };
+use fil_actors_runtime::runtime::Policy;
 use fil_actors_runtime::CRON_ACTOR_ADDR;
 use fvm_ipld_blockstore::MemoryBlockstore;
 use fvm_ipld_encoding::RawBytes;
@@ -167,5 +168,9 @@ pub fn batch_onboarding_test(v: &dyn VM, v2: bool) {
     );
     assert!(network_stats.total_pledge_collateral.is_positive());
 
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }

test_vm/tests/change_beneficiary_test.rs

@@ -1,6 +1,7 @@
 use fil_actor_miner::{
     ActiveBeneficiary, ChangeBeneficiaryParams, Method as MinerMethod, PendingBeneficiaryChange,
 };
+use fil_actors_runtime::runtime::Policy;
 use fvm_ipld_blockstore::MemoryBlockstore;
 use fvm_shared::bigint::Zero;
 use fvm_shared::econ::TokenAmount;
@@ -71,7 +72,7 @@ fn change_beneficiary_success_test(v: &dyn VM) {
     get_beneficiary_return = get_beneficiary(v, &query_addr, &miner_id);
     assert!(get_beneficiary_return.proposed.is_none());
     assert_active(&change_another_beneificiary_proposal, &get_beneficiary_return.active);
-    assert_invariants(v);
+    assert_invariants(v, &Policy::default());
 }
 
 #[test]
@@ -235,7 +236,7 @@ fn change_beneficiary_fail_test(v: &dyn VM) {
     change_beneficiary(v, &owner, &miner_id, &back_owner_proposal);
     change_beneficiary(v, &beneficiary, &miner_id, &back_owner_proposal);
 
-    assert_invariants(v)
+    assert_invariants(v, &Policy::default())
 }
 
 fn assert_pending(

test_vm/tests/change_owner_test.rs

@@ -1,4 +1,5 @@
 use fil_actor_miner::{ChangeBeneficiaryParams, Method as MinerMethod};
+use fil_actors_runtime::runtime::Policy;
 use fvm_ipld_blockstore::MemoryBlockstore;
 use fvm_shared::bigint::Zero;
 use fvm_shared::econ::TokenAmount;
@@ -48,7 +49,7 @@ fn change_owner_success_test(v: &dyn VM) {
     assert_eq!(new_owner, minfo.owner);
     assert_eq!(new_owner, minfo.beneficiary);
 
-    assert_invariants(v)
+    assert_invariants(v, &Policy::default())
 }
 
 #[test]
@@ -94,7 +95,7 @@ fn keep_beneficiary_when_owner_changed_test(v: &dyn VM) {
     assert_eq!(new_owner, minfo.owner);
     assert_eq!(beneficiary, minfo.beneficiary);
 
-    assert_invariants(v)
+    assert_invariants(v, &Policy::default())
 }
 
 #[test]
@@ -171,5 +172,5 @@ fn change_owner_fail_test(v: &dyn VM) {
     assert_eq!(addr, minfo.owner);
     assert_eq!(addr, minfo.beneficiary);
 
-    assert_invariants(v)
+    assert_invariants(v, &Policy::default())
 }

test_vm/tests/commit_post_test.rs

@@ -181,7 +181,7 @@ fn submit_post_succeeds_test(v: &dyn VM, miner_info: MinerInfo, sector_info: Sec
     let p_st: PowerState = get_state(v, &STORAGE_POWER_ACTOR_ADDR).unwrap();
     assert_eq!(sector_power.raw, p_st.total_bytes_committed);
 
-    assert_invariants(v);
+    assert_invariants(v, &Policy::default());
 }
 
 #[test]
@@ -226,7 +226,7 @@ fn skip_sector_test(v: &dyn VM, sector_info: SectorInfo, miner_info: MinerInfo)
     let network_stats = get_network_stats(v);
     assert!(network_stats.total_bytes_committed.is_zero());
     assert!(network_stats.total_pledge_collateral.is_positive());
-    assert_invariants(v)
+    assert_invariants(v, &Policy::default())
 }
 
 #[test]
@@ -289,7 +289,11 @@ fn missed_first_post_deadline_test(v: &dyn VM, sector_info: SectorInfo, miner_in
     assert!(network_stats.total_bytes_committed.is_zero());
     assert!(network_stats.total_pledge_collateral.is_positive());
 
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }
 
 #[test]
@@ -397,7 +401,11 @@ fn overdue_precommit_test(v: &dyn VM) {
     assert!(network_stats.total_raw_byte_power.is_zero());
     assert!(network_stats.total_quality_adj_power.is_zero());
 
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }
 
 #[test]
@@ -470,7 +478,11 @@ fn aggregate_bad_sector_number_test(v: &dyn VM) {
         Some(params),
         ExitCode::USR_ILLEGAL_ARGUMENT,
     );
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }
 
 #[test]
@@ -575,7 +587,11 @@ fn aggregate_size_limits_test(v: &dyn VM) {
         ExitCode::USR_ILLEGAL_ARGUMENT,
     );
 
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }
 
 #[test]
@@ -644,7 +660,11 @@ fn aggregate_bad_sender_test(v: &dyn VM) {
         Some(params),
         ExitCode::USR_FORBIDDEN,
     );
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }
 
 #[test]
@@ -763,5 +783,9 @@ fn aggregate_one_precommit_expires_test(v: &dyn VM) {
     assert!(balances.initial_pledge.is_positive());
     assert!(balances.pre_commit_deposit.is_positive());
 
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }

test_vm/tests/extend_sectors_test.rs

@@ -333,7 +333,11 @@ fn extend_legacy_sector_with_deals_inner<BS: Blockstore>(
     // 1/2 * 2/3 -> 1/3
     assert_eq!(initial_verified_deal_weight / 3, sector_info.verified_deal_weight);
 
-    expect_invariants(v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }
 
 #[test]

test_vm/tests/init_test.rs

@@ -12,7 +12,7 @@ use test_vm::{actor, util::serialize_ok, TestVM, FIRST_TEST_USER_ADDR, TEST_FAUC
 
 fn assert_placeholder_actor(exp_bal: TokenAmount, v: &dyn VM, addr: Address) {
     let act = v.actor(&addr).unwrap();
-    assert_eq!(EMPTY_ARR_CID, act.head);
+    assert_eq!(EMPTY_ARR_CID, act.state);
     assert_eq!(*PLACEHOLDER_ACTOR_CODE_ID, act.code);
     assert_eq!(exp_bal, act.balance);
 }

test_vm/tests/multisig_test.rs

@@ -4,6 +4,7 @@ use fil_actor_multisig::{
     State as MsigState, SwapSignerParams, Transaction, TxnID, TxnIDParams,
 };
 use fil_actors_runtime::cbor::serialize;
+use fil_actors_runtime::runtime::Policy;
 use fil_actors_runtime::test_utils::*;
 use fil_actors_runtime::{make_map_with_root, INIT_ACTOR_ADDR, SYSTEM_ACTOR_ADDR};
 use fvm_ipld_blockstore::MemoryBlockstore;
@@ -27,17 +28,15 @@ use test_vm::{TestVM, VM};
 fn proposal_hash() {
     let store = MemoryBlockstore::new();
     let v = TestVM::<MemoryBlockstore>::new_with_singletons(&store);
-    let addrs = create_accounts(&v, 3, &TokenAmount::from_whole(10_000));
-    let sys_act_start_bal = v.get_actor(&SYSTEM_ACTOR_ADDR).unwrap().balance;
-    let fil_delta = proposal_hash_test(&v, &addrs);
-    assert_eq!(sys_act_start_bal + fil_delta, v.get_actor(&SYSTEM_ACTOR_ADDR).unwrap().balance);
-    assert_invariants(&v)
+    proposal_hash_test(&v);
 }
 
-fn proposal_hash_test(v: &dyn VM, addrs: &[Address]) -> TokenAmount {
+fn proposal_hash_test(v: &dyn VM) {
+    let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000));
+    let sys_act_start_bal = v.actor(&SYSTEM_ACTOR_ADDR).unwrap().balance;
     let alice = addrs[0];
     let bob = addrs[1];
-    let msig_addr = create_msig(v, addrs, 2);
+    let msig_addr = create_msig(v, &addrs, 2);
 
     // fund msig and propose send funds to system actor
     let fil_delta = TokenAmount::from_nano(3);
@@ -108,7 +107,9 @@ fn proposal_hash_test(v: &dyn VM, addrs: &[Address]) -> TokenAmount {
         ..Default::default()
     };
     expect.matches(v.take_invocations().last().unwrap());
-    fil_delta
+
+    assert_eq!(sys_act_start_bal + fil_delta, v.actor(&SYSTEM_ACTOR_ADDR).unwrap().balance);
+    assert_invariants(v, &Policy::default())
 }
 
 #[test]
@@ -176,7 +177,7 @@ fn test_delete_self() {
         let new_signers: HashSet<Address> = HashSet::from_iter(st.signers);
         let diff: Vec<&Address> = old_signers.symmetric_difference(&new_signers).collect();
         assert_eq!(vec![&(addrs[remove_idx])], diff);
-        assert_invariants(&v)
+        assert_invariants(&v, &Policy::default())
     };
     test(2, 3, 0); // 2 of 3 removed is proposer
     test(2, 3, 1); // 2 of 3 removed is approver
@@ -213,7 +214,7 @@ fn swap_self_1_of_2_test(v: &dyn VM) {
     );
     let st: MsigState = get_state(v, &msig_addr).unwrap();
     assert_eq!(vec![bob, chuck], st.signers);
-    assert_invariants(v);
+    assert_invariants(v, &Policy::default());
 }
 
 #[test]
@@ -291,7 +292,7 @@ fn swap_self_2_of_3_test(v: &dyn VM) {
     let st: MsigState = get_state(v, &msig_addr).unwrap();
     assert_eq!(vec![bob, chuck, alice], st.signers);
 
-    assert_invariants(v)
+    assert_invariants(v, &Policy::default())
 }
 
 fn create_msig(v: &dyn VM, signers: &[Address], threshold: u64) -> Address {

test_vm/tests/power_scenario_tests.rs

@@ -102,7 +102,7 @@ fn power_create_miner_test(v: &dyn VM) {
     };
 
     expect.matches(v.take_invocations().last().unwrap());
-    assert_invariants(v);
+    assert_invariants(v, &Policy::default());
 }
 
 #[test]
@@ -215,5 +215,9 @@ fn test_cron_tick() {
     }
     .matches(v.take_invocations().first().unwrap());
 
-    expect_invariants(&v, &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()]);
+    expect_invariants(
+        &v,
+        &Policy::default(),
+        &[invariant_failure_patterns::REWARD_STATE_EPOCH_MISMATCH.to_owned()],
+    );
 }