From 8e82ef71a1858d0530e74e778056dc1b67981587 Mon Sep 17 00:00:00 2001 From: Alex Su <7680266+alexytsu@users.noreply.github.com> Date: Fri, 14 Jul 2023 10:10:00 +1000 Subject: [PATCH] Have VM trait expose a dyn blockstore (#1328) * wip * refactor VM trait to return a dyn Blockstore * refactor miner_withdrawal_tests to not need BS: Blockstore * VM trait should use abstract primitives (#1329) --- test_vm/src/deals.rs | 15 +- test_vm/src/lib.rs | 14 +- test_vm/src/util/blockstore.rs | 22 ++ test_vm/src/{util.rs => util/mod.rs} | 203 +++++++++--------- test_vm/tests/authenticate_message_test.rs | 4 +- test_vm/tests/batch_onboarding.rs | 8 +- test_vm/tests/batch_onboarding_deals_test.rs | 24 ++- test_vm/tests/change_beneficiary_test.rs | 8 +- test_vm/tests/change_owner_test.rs | 8 +- test_vm/tests/commit_post_test.rs | 34 ++- test_vm/tests/datacap_tests.rs | 6 +- test_vm/tests/evm_test.rs | 21 +- test_vm/tests/extend_sectors_test.rs | 32 ++- test_vm/tests/init_test.rs | 4 +- test_vm/tests/market_miner_withdrawal_test.rs | 95 +++++--- test_vm/tests/multisig_test.rs | 30 +-- test_vm/tests/power_scenario_tests.rs | 4 +- test_vm/tests/publish_deals_test.rs | 57 ++--- test_vm/tests/replica_update_test.rs | 72 ++++--- test_vm/tests/terminate_test.rs | 18 +- test_vm/tests/verified_claim_test.rs | 81 ++++--- test_vm/tests/verifreg_remove_datacap_test.rs | 52 ++--- test_vm/tests/withdraw_balance_test.rs | 8 +- 23 files changed, 439 insertions(+), 381 deletions(-) create mode 100644 test_vm/src/util/blockstore.rs rename test_vm/src/{util.rs => util/mod.rs} (90%) diff --git a/test_vm/src/deals.rs b/test_vm/src/deals.rs index 3e009382b..d1c585823 100644 --- a/test_vm/src/deals.rs +++ b/test_vm/src/deals.rs @@ -8,7 +8,6 @@ use fil_actors_runtime::cbor::serialize; use fil_actors_runtime::runtime::Policy; use fil_actors_runtime::test_utils::make_piece_cid; use fil_actors_runtime::STORAGE_MARKET_ACTOR_ADDR; -use fvm_ipld_blockstore::Blockstore; use fvm_shared::address::Address; use fvm_shared::clock::ChainEpoch; use fvm_shared::crypto::signature::{Signature, SignatureType}; @@ -45,21 +44,15 @@ impl Default for DealOptions { // A helper for staging and publishing deals. // Note that this doesn't check trace expectations, // see https://github.com/filecoin-project/builtin-actors/issues/1302. -pub struct DealBatcher<'vm, BS> -where - BS: Blockstore, -{ - v: &'vm dyn VM, +pub struct DealBatcher<'vm> { + v: &'vm dyn VM, deals: Vec, default_options: DealOptions, published: bool, } -impl<'vm, BS> DealBatcher<'vm, BS> -where - BS: Blockstore, -{ - pub fn new(v: &'vm dyn VM, opts: DealOptions) -> Self { +impl<'vm> DealBatcher<'vm> { + pub fn new(v: &'vm dyn VM, opts: DealOptions) -> Self { DealBatcher { v, deals: vec![], default_options: opts, published: false } } diff --git a/test_vm/src/lib.rs b/test_vm/src/lib.rs index b976b48c5..42887e669 100644 --- a/test_vm/src/lib.rs +++ b/test_vm/src/lib.rs @@ -83,9 +83,9 @@ pub mod trace; pub mod util; /// An abstract VM that is injected into integration tests -pub trait VM { +pub trait VM { /// Returns the underlying blockstore of the VM - fn blockstore(&self) -> Box<&BS>; + fn blockstore(&self) -> &dyn Blockstore; /// Get the state root of the specified actor fn actor_root(&self, address: &Address) -> Option; @@ -122,7 +122,7 @@ pub trait VM { fn actor_manifest(&self) -> BiBTreeMap; /// Provides access to VM primitives - fn primitives(&self) -> &FakePrimitives; + fn primitives(&self) -> &dyn Primitives; /// Get the current runtime policy fn policy(&self) -> Policy; @@ -186,12 +186,12 @@ pub const FAUCET_ROOT_KEY: &[u8] = &[153; fvm_shared::address::BLS_PUB_LEN]; pub const TEST_FAUCET_ADDR: Address = Address::new_id(FIRST_NON_SINGLETON_ADDR + 2); pub const FIRST_TEST_USER_ADDR: ActorID = FIRST_NON_SINGLETON_ADDR + 3; -impl<'bs, BS> VM for TestVM<'bs, BS> +impl<'bs, BS> VM for TestVM<'bs, BS> where BS: Blockstore, { - fn blockstore(&self) -> Box<&BS> { - Box::new(self.store) + fn blockstore(&self) -> &dyn Blockstore { + self.store } fn epoch(&self) -> ChainEpoch { @@ -326,7 +326,7 @@ where self.total_fil.clone() } - fn primitives(&self) -> &FakePrimitives { + fn primitives(&self) -> &dyn Primitives { &self.primitives } } diff --git a/test_vm/src/util/blockstore.rs b/test_vm/src/util/blockstore.rs new file mode 100644 index 000000000..bbafb607d --- /dev/null +++ b/test_vm/src/util/blockstore.rs @@ -0,0 +1,22 @@ +use cid::Cid; +use fvm_ipld_blockstore::Blockstore; + +/// A DynBlockstore is used to make the blockstore trait object consumable by functions that +/// accept a generic BS: Blockstore parameter rather than a dyn Blockstore +pub struct DynBlockstore<'bs>(&'bs dyn Blockstore); + +impl<'bs> Blockstore for DynBlockstore<'bs> { + fn get(&self, k: &Cid) -> anyhow::Result>> { + self.0.get(k) + } + + fn put_keyed(&self, k: &Cid, block: &[u8]) -> anyhow::Result<()> { + self.0.put_keyed(k, block) + } +} + +impl<'bs> DynBlockstore<'bs> { + pub fn wrap(blockstore: &'bs dyn Blockstore) -> Self { + Self(blockstore) + } +} diff --git a/test_vm/src/util.rs b/test_vm/src/util/mod.rs similarity index 90% rename from test_vm/src/util.rs rename to test_vm/src/util/mod.rs index 815049099..fb175c48a 100644 --- a/test_vm/src/util.rs +++ b/test_vm/src/util/mod.rs @@ -55,6 +55,9 @@ use crate::expects::Expect; use crate::trace::ExpectInvocation; use crate::*; +mod blockstore; +pub use blockstore::DynBlockstore; + // Generate count addresses by seeding an rng pub fn pk_addrs_from(seed: u64, count: u64) -> Vec
{ let mut seed_arr = [0u8; 32]; @@ -74,16 +77,12 @@ fn new_bls_from_rng(rng: &mut ChaCha8Rng) -> Address { const ACCOUNT_SEED: u64 = 93837778; -pub fn create_accounts( - v: &dyn VM, - count: u64, - balance: &TokenAmount, -) -> Vec
{ +pub fn create_accounts(v: &dyn VM, count: u64, balance: &TokenAmount) -> Vec
{ create_accounts_seeded(v, count, balance, ACCOUNT_SEED) } -pub fn create_accounts_seeded( - v: &dyn VM, +pub fn create_accounts_seeded( + v: &dyn VM, count: u64, balance: &TokenAmount, seed: u64, @@ -97,8 +96,8 @@ pub fn create_accounts_seeded( pk_addrs.iter().map(|pk_addr| v.resolve_id_address(pk_addr).unwrap()).collect() } -pub fn apply_ok( - v: &dyn VM, +pub fn apply_ok( + v: &dyn VM, from: &Address, to: &Address, value: &TokenAmount, @@ -108,8 +107,8 @@ pub fn apply_ok( apply_code(v, from, to, value, method, params, ExitCode::OK) } -pub fn apply_code( - v: &dyn VM, +pub fn apply_code( + v: &dyn VM, from: &Address, to: &Address, value: &TokenAmount, @@ -128,7 +127,7 @@ pub fn serialize_ok(s: &S) -> IpldBlock { IpldBlock::serialize_cbor(s).unwrap().unwrap() } -pub fn cron_tick(v: &dyn VM) { +pub fn cron_tick(v: &dyn VM) { apply_ok( v, &SYSTEM_ACTOR_ADDR, @@ -139,8 +138,8 @@ pub fn cron_tick(v: &dyn VM) { ); } -pub fn create_miner( - v: &dyn VM, +pub fn create_miner( + v: &dyn VM, owner: &Address, worker: &Address, post_proof_type: RegisteredPoStProof, @@ -173,8 +172,8 @@ pub fn create_miner( (res.id_address, res.robust_address) } -pub fn miner_precommit_sector( - v: &dyn VM, +pub fn miner_precommit_sector( + v: &dyn VM, worker: &Address, miner_id: &Address, seal_proof: RegisteredSealProof, @@ -207,11 +206,14 @@ pub fn miner_precommit_sector( ); let state: MinerState = get_state(v, miner_id).unwrap(); - state.get_precommitted_sector(*v.blockstore(), sector_number).unwrap().unwrap() + state + .get_precommitted_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap() } -pub fn miner_prove_sector( - v: &dyn VM, +pub fn miner_prove_sector( + v: &dyn VM, worker: &Address, miner_id: &Address, sector_number: SectorNumber, @@ -247,8 +249,8 @@ pub struct PrecommitMetadata { } #[allow(clippy::too_many_arguments)] -pub fn precommit_sectors_v2( - v: &dyn VM, +pub fn precommit_sectors_v2( + v: &dyn VM, count: usize, batch_size: usize, metadata: Vec, // Per-sector deal metadata, or empty vector for no deals. @@ -410,7 +412,10 @@ pub fn precommit_sectors_v2( (0..count) .map(|i| { mstate - .get_precommitted_sector(*v.blockstore(), sector_number_base + i as u64) + .get_precommitted_sector( + &DynBlockstore::wrap(v.blockstore()), + sector_number_base + i as u64, + ) .unwrap() .unwrap() }) @@ -418,8 +423,8 @@ pub fn precommit_sectors_v2( } #[allow(clippy::too_many_arguments)] -pub fn precommit_sectors( - v: &dyn VM, +pub fn precommit_sectors( + v: &dyn VM, count: usize, batch_size: usize, worker: &Address, @@ -444,8 +449,8 @@ pub fn precommit_sectors( ) } -pub fn prove_commit_sectors( - v: &dyn VM, +pub fn prove_commit_sectors( + v: &dyn VM, worker: &Address, maddr: &Address, precommits: Vec, @@ -495,8 +500,8 @@ pub fn prove_commit_sectors( } #[allow(clippy::too_many_arguments)] -pub fn miner_extend_sector_expiration2( - v: &dyn VM, +pub fn miner_extend_sector_expiration2( + v: &dyn VM, worker: &Address, miner: &Address, deadline: u64, @@ -551,11 +556,7 @@ pub fn miner_extend_sector_expiration2( .matches(v.take_invocations().last().unwrap()); } -pub fn advance_by_deadline_to_epoch( - v: &dyn VM, - maddr: &Address, - e: ChainEpoch, -) -> DeadlineInfo { +pub fn advance_by_deadline_to_epoch(v: &dyn VM, maddr: &Address, e: ChainEpoch) -> DeadlineInfo { // keep advancing until the epoch of interest is within the deadline // if e is dline.last() == dline.close -1 cron is not run let dline_info = advance_by_deadline(v, maddr, |dline_info| dline_info.close < e); @@ -563,16 +564,12 @@ pub fn advance_by_deadline_to_epoch( dline_info } -pub fn advance_by_deadline_to_index( - v: &dyn VM, - maddr: &Address, - i: u64, -) -> DeadlineInfo { +pub fn advance_by_deadline_to_index(v: &dyn VM, maddr: &Address, i: u64) -> DeadlineInfo { advance_by_deadline(v, maddr, |dline_info| dline_info.index != i) } -pub fn advance_by_deadline_to_epoch_while_proving( - v: &dyn VM, +pub fn advance_by_deadline_to_epoch_while_proving( + v: &dyn VM, maddr: &Address, worker: &Address, s: SectorNumber, @@ -595,8 +592,8 @@ pub fn advance_by_deadline_to_epoch_while_proving( } } -pub fn advance_to_proving_deadline( - v: &dyn VM, +pub fn advance_to_proving_deadline( + v: &dyn VM, maddr: &Address, s: SectorNumber, ) -> (DeadlineInfo, u64) { @@ -606,7 +603,7 @@ pub fn advance_to_proving_deadline( (dline_info, p) } -fn advance_by_deadline(v: &dyn VM, maddr: &Address, more: F) -> DeadlineInfo +fn advance_by_deadline(v: &dyn VM, maddr: &Address, more: F) -> DeadlineInfo where F: Fn(DeadlineInfo) -> bool, { @@ -622,12 +619,12 @@ where } } -pub fn get_state(v: &dyn VM, a: &Address) -> Option { +pub fn get_state(v: &dyn VM, a: &Address) -> Option { let cid = v.actor_root(a).unwrap(); v.blockstore().get(&cid).unwrap().map(|slice| fvm_ipld_encoding::from_slice(&slice).unwrap()) } -pub fn miner_balance(v: &dyn VM, m: &Address) -> MinerBalances { +pub fn miner_balance(v: &dyn VM, m: &Address) -> MinerBalances { let st: MinerState = get_state(v, m).unwrap(); MinerBalances { available_balance: st.get_available_balance(&v.balance(m)).unwrap(), @@ -637,66 +634,70 @@ pub fn miner_balance(v: &dyn VM, m: &Address) -> MinerBalanc } } -pub fn miner_info(v: &dyn VM, m: &Address) -> MinerInfo { +pub fn miner_info(v: &dyn VM, m: &Address) -> MinerInfo { let st: MinerState = get_state(v, m).unwrap(); - v.blockstore().get_cbor(&st.info).unwrap().unwrap() + DynBlockstore::wrap(v.blockstore()).get_cbor(&st.info).unwrap().unwrap() } -pub fn miner_dline_info(v: &dyn VM, m: &Address) -> DeadlineInfo { +pub fn miner_dline_info(v: &dyn VM, m: &Address) -> DeadlineInfo { let st: MinerState = get_state(v, m).unwrap(); new_deadline_info_from_offset_and_epoch(&Policy::default(), st.proving_period_start, v.epoch()) } -pub fn sector_deadline(v: &dyn VM, m: &Address, s: SectorNumber) -> (u64, u64) { +pub fn sector_deadline(v: &dyn VM, m: &Address, s: SectorNumber) -> (u64, u64) { let st: MinerState = get_state(v, m).unwrap(); - st.find_sector(&Policy::default(), *v.blockstore(), s).unwrap() + st.find_sector(&Policy::default(), &DynBlockstore::wrap(v.blockstore()), s).unwrap() } -pub fn check_sector_active(v: &dyn VM, m: &Address, s: SectorNumber) -> bool { +pub fn check_sector_active(v: &dyn VM, m: &Address, s: SectorNumber) -> bool { let (d_idx, p_idx) = sector_deadline(v, m, s); let st: MinerState = get_state(v, m).unwrap(); - st.check_sector_active(&Policy::default(), *v.blockstore(), d_idx, p_idx, s, true).unwrap() + st.check_sector_active( + &Policy::default(), + &DynBlockstore::wrap(v.blockstore()), + d_idx, + p_idx, + s, + true, + ) + .unwrap() } -pub fn check_sector_faulty( - v: &dyn VM, +pub fn check_sector_faulty( + v: &dyn VM, m: &Address, d_idx: u64, p_idx: u64, s: SectorNumber, ) -> bool { let st: MinerState = get_state(v, m).unwrap(); - let bs = *v.blockstore(); + let bs = &DynBlockstore::wrap(v.blockstore()); let deadlines = st.load_deadlines(bs).unwrap(); let deadline = deadlines.load_deadline(&Policy::default(), bs, d_idx).unwrap(); let partition = deadline.load_partition(bs, p_idx).unwrap(); partition.faults.get(s) } -pub fn deadline_state(v: &dyn VM, m: &Address, d_idx: u64) -> Deadline { +pub fn deadline_state(v: &dyn VM, m: &Address, d_idx: u64) -> Deadline { let st: MinerState = get_state(v, m).unwrap(); - let bs = *v.blockstore(); + let bs = &DynBlockstore::wrap(v.blockstore()); let deadlines = st.load_deadlines(bs).unwrap(); deadlines.load_deadline(&Policy::default(), bs, d_idx).unwrap() } -pub fn sector_info( - v: &dyn VM, - m: &Address, - s: SectorNumber, -) -> SectorOnChainInfo { +pub fn sector_info(v: &dyn VM, m: &Address, s: SectorNumber) -> SectorOnChainInfo { let st: MinerState = get_state(v, m).unwrap(); - st.get_sector(*v.blockstore(), s).unwrap().unwrap() + st.get_sector(&DynBlockstore::wrap(v.blockstore()), s).unwrap().unwrap() } -pub fn miner_power(v: &dyn VM, m: &Address) -> PowerPair { +pub fn miner_power(v: &dyn VM, m: &Address) -> PowerPair { let st: PowerState = get_state(v, &STORAGE_POWER_ACTOR_ADDR).unwrap(); - let claim = st.get_claim(*v.blockstore(), m).unwrap().unwrap(); + let claim = st.get_claim(&DynBlockstore::wrap(v.blockstore()), m).unwrap().unwrap(); PowerPair::new(claim.raw_byte_power, claim.quality_adj_power) } -pub fn declare_recovery( - v: &dyn VM, +pub fn declare_recovery( + v: &dyn VM, worker: &Address, maddr: &Address, deadline: u64, @@ -721,8 +722,8 @@ pub fn declare_recovery( ); } -pub fn submit_windowed_post( - v: &dyn VM, +pub fn submit_windowed_post( + v: &dyn VM, worker: &Address, maddr: &Address, dline_info: DeadlineInfo, @@ -766,8 +767,8 @@ pub fn submit_windowed_post( .matches(v.take_invocations().last().unwrap()); } -pub fn change_beneficiary( - v: &dyn VM, +pub fn change_beneficiary( + v: &dyn VM, from: &Address, maddr: &Address, beneficiary_change_proposal: &ChangeBeneficiaryParams, @@ -782,25 +783,25 @@ pub fn change_beneficiary( ); } -pub fn check_invariants(vm: &dyn VM) -> anyhow::Result { +pub fn check_invariants(vm: &dyn VM) -> anyhow::Result { check_state_invariants( &vm.actor_manifest(), &vm.policy(), - Tree::load(*vm.blockstore(), &vm.state_root()).unwrap(), + Tree::load(&DynBlockstore::wrap(vm.blockstore()), &vm.state_root()).unwrap(), &vm.total_fil(), vm.epoch() - 1, ) } -pub fn assert_invariants(vm: &dyn VM) { +pub fn assert_invariants(vm: &dyn VM) { check_invariants(vm).unwrap().assert_empty() } -pub fn expect_invariants(vm: &dyn VM, expected_patterns: &[Regex]) { +pub fn expect_invariants(vm: &dyn VM, expected_patterns: &[Regex]) { check_invariants(vm).unwrap().assert_expected(expected_patterns) } -pub fn get_network_stats(vm: &dyn VM) -> NetworkStats { +pub fn get_network_stats(vm: &dyn VM) -> NetworkStats { let power_state: PowerState = get_state(vm, &STORAGE_POWER_ACTOR_ADDR).unwrap(); let reward_state: RewardState = get_state(vm, &REWARD_ACTOR_ADDR).unwrap(); let market_state: MarketState = get_state(vm, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); @@ -826,11 +827,7 @@ pub fn get_network_stats(vm: &dyn VM) -> NetworkStats { } } -pub fn get_beneficiary( - v: &dyn VM, - from: &Address, - m_addr: &Address, -) -> GetBeneficiaryReturn { +pub fn get_beneficiary(v: &dyn VM, from: &Address, m_addr: &Address) -> GetBeneficiaryReturn { apply_ok( v, from, @@ -843,8 +840,8 @@ pub fn get_beneficiary( .unwrap() } -pub fn change_owner_address( - v: &dyn VM, +pub fn change_owner_address( + v: &dyn VM, from: &Address, m_addr: &Address, new_miner_addr: &Address, @@ -859,8 +856,8 @@ pub fn change_owner_address( ); } -pub fn withdraw_balance( - v: &dyn VM, +pub fn withdraw_balance( + v: &dyn VM, from: &Address, m_addr: &Address, to_withdraw_amount: &TokenAmount, @@ -897,8 +894,8 @@ pub fn withdraw_balance( assert_eq!(expect_withdraw_amount, &withdraw_return.amount_withdrawn); } -pub fn submit_invalid_post( - v: &dyn VM, +pub fn submit_invalid_post( + v: &dyn VM, worker: &Address, maddr: &Address, dline_info: DeadlineInfo, @@ -924,11 +921,7 @@ pub fn submit_invalid_post( ); } -pub fn verifreg_add_verifier( - v: &dyn VM, - verifier: &Address, - data_cap: StoragePower, -) { +pub fn verifreg_add_verifier(v: &dyn VM, verifier: &Address, data_cap: StoragePower) { let add_verifier_params = VerifierParams { address: *verifier, allowance: data_cap }; // root address is msig, send proposal from root key let proposal = ProposeParams { @@ -967,8 +960,8 @@ pub fn verifreg_add_verifier( .matches(v.take_invocations().last().unwrap()); } -pub fn verifreg_add_client( - v: &dyn VM, +pub fn verifreg_add_client( + v: &dyn VM, verifier: &Address, client: &Address, allowance: StoragePower, @@ -1016,8 +1009,8 @@ pub fn verifreg_add_client( .matches(v.take_invocations().last().unwrap()); } -pub fn verifreg_extend_claim_terms( - v: &dyn VM, +pub fn verifreg_extend_claim_terms( + v: &dyn VM, client: &Address, provider: &Address, claim: ClaimID, @@ -1040,8 +1033,8 @@ pub fn verifreg_extend_claim_terms( ); } -pub fn verifreg_remove_expired_allocations( - v: &dyn VM, +pub fn verifreg_remove_expired_allocations( + v: &dyn VM, caller: &Address, client: &Address, ids: Vec, @@ -1089,7 +1082,7 @@ pub fn verifreg_remove_expired_allocations( .matches(v.take_invocations().last().unwrap()); } -pub fn datacap_get_balance(v: &dyn VM, address: &Address) -> TokenAmount { +pub fn datacap_get_balance(v: &dyn VM, address: &Address) -> TokenAmount { let ret = apply_ok( v, address, @@ -1101,8 +1094,8 @@ pub fn datacap_get_balance(v: &dyn VM, address: &Address) -> deserialize(&ret, "balance of return value").unwrap() } -pub fn datacap_extend_claim( - v: &dyn VM, +pub fn datacap_extend_claim( + v: &dyn VM, client: &Address, provider: &Address, claim: ClaimID, @@ -1172,8 +1165,8 @@ pub fn datacap_extend_claim( .matches(v.take_invocations().last().unwrap()); } -pub fn market_add_balance( - v: &dyn VM, +pub fn market_add_balance( + v: &dyn VM, sender: &Address, beneficiary: &Address, amount: &TokenAmount, @@ -1189,8 +1182,8 @@ pub fn market_add_balance( } #[allow(clippy::too_many_arguments)] -pub fn market_publish_deal( - v: &dyn VM, +pub fn market_publish_deal( + v: &dyn VM, worker: &Address, deal_client: &Address, miner_id: &Address, diff --git a/test_vm/tests/authenticate_message_test.rs b/test_vm/tests/authenticate_message_test.rs index 0921a4e88..1af728d29 100644 --- a/test_vm/tests/authenticate_message_test.rs +++ b/test_vm/tests/authenticate_message_test.rs @@ -1,6 +1,6 @@ use fil_actor_account::types::AuthenticateMessageParams; use fil_actor_account::Method::AuthenticateMessageExported; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::RawBytes; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; @@ -19,7 +19,7 @@ fn account_authenticate_message() { /// Using a deal proposal as a serialized message, we confirm that: /// - calls to Account::authenticate_message with valid signatures succeed /// - calls to Account::authenticate_message with invalid signatures fail -pub fn account_authenticate_message_test(v: &dyn VM) { +pub fn account_authenticate_message_test(v: &dyn VM) { let addr = create_accounts(v, 1, &TokenAmount::from_whole(10_000))[0]; let proposal = diff --git a/test_vm/tests/batch_onboarding.rs b/test_vm/tests/batch_onboarding.rs index f379550f1..59341c2e4 100644 --- a/test_vm/tests/batch_onboarding.rs +++ b/test_vm/tests/batch_onboarding.rs @@ -7,7 +7,7 @@ use fil_actors_runtime::runtime::policy_constants::{ MAX_AGGREGATED_SECTORS, PRE_COMMIT_SECTOR_BATCH_MAX_SIZE, }; use fil_actors_runtime::CRON_ACTOR_ADDR; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::RawBytes; use fvm_shared::bigint::{BigInt, Zero}; use fvm_shared::econ::TokenAmount; @@ -16,7 +16,7 @@ use test_case::test_case; use test_vm::util::{ advance_to_proving_deadline, apply_ok, create_accounts, create_miner, expect_invariants, get_network_stats, get_state, invariant_failure_patterns, miner_balance, precommit_sectors_v2, - prove_commit_sectors, submit_windowed_post, + prove_commit_sectors, submit_windowed_post, DynBlockstore, }; use test_vm::{TestVM, VM}; @@ -56,7 +56,7 @@ fn batch_onboarding(v2: bool) { batch_onboarding_test(&v, v2); } -pub fn batch_onboarding_test(v: &dyn VM, v2: bool) { +pub fn batch_onboarding_test(v: &dyn VM, v2: bool) { let seal_proof = &RegisteredSealProof::StackedDRG32GiBV1P1; let mut proven_count = 0; @@ -132,7 +132,7 @@ pub fn batch_onboarding_test(v: &dyn VM, v2: bool) { // submit post let st: MinerState = get_state(v, &id_addr).unwrap(); - let sector = st.get_sector(*v.blockstore(), 0).unwrap().unwrap(); + let sector = st.get_sector(&DynBlockstore::wrap(v.blockstore()), 0).unwrap().unwrap(); let mut new_power = power_for_sector(seal_proof.sector_size().unwrap(), §or); new_power.raw *= proven_count; new_power.qa *= proven_count; diff --git a/test_vm/tests/batch_onboarding_deals_test.rs b/test_vm/tests/batch_onboarding_deals_test.rs index 1915a34c2..351f65303 100644 --- a/test_vm/tests/batch_onboarding_deals_test.rs +++ b/test_vm/tests/batch_onboarding_deals_test.rs @@ -1,4 +1,4 @@ -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_hamt::BytesKey; use fvm_shared::address::Address; use fvm_shared::bigint::BigInt; @@ -16,14 +16,14 @@ use fil_actor_miner::{ }; use fil_actor_miner::{Method as MinerMethod, ProveCommitAggregateParams}; use fil_actors_runtime::runtime::policy::policy_constants::PRE_COMMIT_CHALLENGE_DELAY; -use fil_actors_runtime::runtime::{Policy, Primitives}; +use fil_actors_runtime::runtime::Policy; use fil_actors_runtime::STORAGE_MARKET_ACTOR_ADDR; use test_vm::deals::{DealBatcher, DealOptions}; use test_vm::util::{ advance_to_proving_deadline, apply_ok, bf_all, create_accounts, create_miner, get_network_stats, get_state, make_bitfield, market_add_balance, miner_balance, precommit_sectors_v2, submit_windowed_post, verifreg_add_client, verifreg_add_verifier, - PrecommitMetadata, + DynBlockstore, PrecommitMetadata, }; use test_vm::{TestVM, VM}; @@ -39,7 +39,7 @@ fn batch_onboarding_deals() { } // Tests batch onboarding of sectors with verified deals. -pub fn batch_onboarding_deals_test(v: &dyn VM) { +pub fn batch_onboarding_deals_test(v: &dyn VM) { let deal_duration: ChainEpoch = Policy::default().min_sector_expiration; let sector_duration: ChainEpoch = deal_duration + Policy::default().market_default_allocation_term_buffer; @@ -73,8 +73,9 @@ pub fn batch_onboarding_deals_test(v: &dyn VM) { let mut market_state: fil_actor_market::State = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); let deal_keys: Vec = deals.iter().map(|(id, _)| deal_id_key(*id)).collect(); - let alloc_ids = - market_state.get_pending_deal_allocation_ids(*v.blockstore(), &deal_keys).unwrap(); + let alloc_ids = market_state + .get_pending_deal_allocation_ids(&DynBlockstore::wrap(v.blockstore()), &deal_keys) + .unwrap(); assert_eq!(BATCH_SIZE, alloc_ids.len()); // Associate deals with sectors. @@ -118,7 +119,8 @@ pub fn batch_onboarding_deals_test(v: &dyn VM) { let sector_size = SEAL_PROOF.sector_size().unwrap(); let st: MinerState = get_state(v, &miner).unwrap(); - let sector = st.get_sector(*v.blockstore(), first_sector_no).unwrap().unwrap(); + let sector = + st.get_sector(&DynBlockstore::wrap(v.blockstore()), first_sector_no).unwrap().unwrap(); let mut expect_new_power = power_for_sector(sector_size, §or); // Confirm the verified deal resulted in QA power. assert_eq!(&expect_new_power.raw * 10, expect_new_power.qa); @@ -139,8 +141,8 @@ pub fn batch_onboarding_deals_test(v: &dyn VM) { assert!(network_stats.total_pledge_collateral.is_positive()); } -fn publish_deals( - v: &dyn VM, +fn publish_deals( + v: &dyn VM, client: Address, provider: Address, worker: Address, @@ -166,8 +168,8 @@ fn publish_deals( // We can do so by unifying with util::prove_commit_sectors, and plumbing through // the information necessary to check expectations of deal activation and FIL+ claims. // https://github.com/filecoin-project/builtin-actors/issues/1302 -pub fn prove_commit_aggregate( - v: &dyn VM, +pub fn prove_commit_aggregate( + v: &dyn VM, worker: &Address, maddr: &Address, precommits: Vec, diff --git a/test_vm/tests/change_beneficiary_test.rs b/test_vm/tests/change_beneficiary_test.rs index fedd130b1..ef7e40f29 100644 --- a/test_vm/tests/change_beneficiary_test.rs +++ b/test_vm/tests/change_beneficiary_test.rs @@ -1,7 +1,7 @@ use fil_actor_miner::{ ActiveBeneficiary, ChangeBeneficiaryParams, Method as MinerMethod, PendingBeneficiaryChange, }; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; use fvm_shared::error::ExitCode; @@ -19,7 +19,7 @@ fn change_beneficiary_success() { change_beneficiary_success_test(&v); } -fn change_beneficiary_success_test(v: &dyn VM) { +fn change_beneficiary_success_test(v: &dyn VM) { let addrs = create_accounts(v, 4, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, beneficiary, another_beneficiary, query_addr) = @@ -81,7 +81,7 @@ fn change_beneficiary_back_owner_success() { change_beneficiary_back_owner_success_test(&v); } -fn change_beneficiary_back_owner_success_test(v: &dyn VM) { +fn change_beneficiary_back_owner_success_test(v: &dyn VM) { let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, beneficiary, query_addr) = (addrs[0], addrs[0], addrs[1], addrs[2]); @@ -138,7 +138,7 @@ fn change_beneficiary_fail() { change_beneficiary_fail_test(&v); } -fn change_beneficiary_fail_test(v: &dyn VM) { +fn change_beneficiary_fail_test(v: &dyn VM) { let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, beneficiary, addr) = (addrs[0], addrs[0], addrs[1], addrs[2]); diff --git a/test_vm/tests/change_owner_test.rs b/test_vm/tests/change_owner_test.rs index 2bd3ac4e3..659ff1b06 100644 --- a/test_vm/tests/change_owner_test.rs +++ b/test_vm/tests/change_owner_test.rs @@ -1,5 +1,5 @@ use fil_actor_miner::{ChangeBeneficiaryParams, Method as MinerMethod}; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; use fvm_shared::error::ExitCode; @@ -17,7 +17,7 @@ fn change_owner_success() { change_owner_success_test(&v); } -fn change_owner_success_test(v: &dyn VM) { +fn change_owner_success_test(v: &dyn VM) { let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, new_owner, beneficiary) = (addrs[0], addrs[0], addrs[1], addrs[2]); @@ -58,7 +58,7 @@ fn keep_beneficiary_when_owner_changed() { keep_beneficiary_when_owner_changed_test(&v); } -fn keep_beneficiary_when_owner_changed_test(v: &dyn VM) { +fn keep_beneficiary_when_owner_changed_test(v: &dyn VM) { let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, new_owner, beneficiary) = (addrs[0], addrs[0], addrs[1], addrs[2]); @@ -104,7 +104,7 @@ fn change_owner_fail() { change_owner_fail_test(&v); } -fn change_owner_fail_test(v: &dyn VM) { +fn change_owner_fail_test(v: &dyn VM) { let addrs = create_accounts(v, 4, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, new_owner, addr) = (addrs[0], addrs[0], addrs[1], addrs[2]); diff --git a/test_vm/tests/commit_post_test.rs b/test_vm/tests/commit_post_test.rs index 2f97c3851..b3de63e16 100644 --- a/test_vm/tests/commit_post_test.rs +++ b/test_vm/tests/commit_post_test.rs @@ -1,5 +1,5 @@ use fvm_ipld_bitfield::BitField; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::ipld_block::IpldBlock; use fvm_ipld_encoding::RawBytes; use fvm_shared::address::Address; @@ -27,6 +27,7 @@ use test_vm::util::{ advance_by_deadline_to_epoch, advance_to_proving_deadline, apply_code, apply_ok, assert_invariants, create_accounts, create_miner, expect_invariants, get_network_stats, get_state, invariant_failure_patterns, miner_balance, precommit_sectors, submit_windowed_post, + DynBlockstore, }; use test_vm::{TestVM, TEST_VM_RAND_ARRAY, VM}; @@ -161,14 +162,11 @@ fn submit_post_succeeds() { submit_post_succeeds_test(&v, miner_info, sector_info); } -fn submit_post_succeeds_test( - v: &dyn VM, - miner_info: MinerInfo, - sector_info: SectorInfo, -) { +fn submit_post_succeeds_test(v: &dyn VM, miner_info: MinerInfo, sector_info: SectorInfo) { // submit post let st: MinerState = get_state(v, &miner_info.miner_id).unwrap(); - let sector = st.get_sector(*v.blockstore(), sector_info.number).unwrap().unwrap(); + let sector = + st.get_sector(&DynBlockstore::wrap(v.blockstore()), sector_info.number).unwrap().unwrap(); let sector_power = power_for_sector(miner_info.seal_proof.sector_size().unwrap(), §or); submit_windowed_post( v, @@ -193,11 +191,7 @@ fn skip_sector() { skip_sector_test(&v, sector_info, miner_info); } -fn skip_sector_test( - v: &dyn VM, - sector_info: SectorInfo, - miner_info: MinerInfo, -) { +fn skip_sector_test(v: &dyn VM, sector_info: SectorInfo, miner_info: MinerInfo) { // submit post, but skip the only sector in it let params = SubmitWindowedPoStParams { deadline: sector_info.deadline_info.index, @@ -243,11 +237,7 @@ fn missed_first_post_deadline() { missed_first_post_deadline_test(&v, sector_info, miner_info); } -fn missed_first_post_deadline_test( - v: &dyn VM, - sector_info: SectorInfo, - miner_info: MinerInfo, -) { +fn missed_first_post_deadline_test(v: &dyn VM, sector_info: SectorInfo, miner_info: MinerInfo) { // move to proving period end v.set_epoch(sector_info.deadline_info.last()); @@ -310,7 +300,7 @@ fn overdue_precommit() { overdue_precommit_test(&v); } -fn overdue_precommit_test(v: &dyn VM) { +fn overdue_precommit_test(v: &dyn VM) { let policy = &Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; @@ -417,7 +407,7 @@ fn aggregate_bad_sector_number() { aggregate_bad_sector_number_test(&v); } -fn aggregate_bad_sector_number_test(v: &dyn VM) { +fn aggregate_bad_sector_number_test(v: &dyn VM) { let addrs = create_accounts(v, 1, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker) = (addrs[0], addrs[0]); @@ -490,7 +480,7 @@ fn aggregate_size_limits() { aggregate_size_limits_test(&v); } -fn aggregate_size_limits_test(v: &dyn VM) { +fn aggregate_size_limits_test(v: &dyn VM) { let oversized_batch = 820; let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; @@ -595,7 +585,7 @@ fn aggregate_bad_sender() { aggregate_bad_sender_test(&v); } -fn aggregate_bad_sender_test(v: &dyn VM) { +fn aggregate_bad_sender_test(v: &dyn VM) { let addrs = create_accounts(v, 2, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker) = (addrs[0], addrs[0]); @@ -664,7 +654,7 @@ fn aggregate_one_precommit_expires() { aggregate_one_precommit_expires_test(&v); } -fn aggregate_one_precommit_expires_test(v: &dyn VM) { +fn aggregate_one_precommit_expires_test(v: &dyn VM) { let addrs = create_accounts(v, 1, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker) = (addrs[0], addrs[0]); diff --git a/test_vm/tests/datacap_tests.rs b/test_vm/tests/datacap_tests.rs index 1bc2ba9c5..5ec3f1594 100644 --- a/test_vm/tests/datacap_tests.rs +++ b/test_vm/tests/datacap_tests.rs @@ -1,4 +1,4 @@ -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; use fvm_shared::piece::PaddedPieceSize; @@ -27,7 +27,7 @@ fn datacap_transfer() { datacap_transfer_test(&v); } -fn datacap_transfer_test(v: &dyn VM) { +fn datacap_transfer_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let (client, operator, owner) = (addrs[0], addrs[1], addrs[2]); @@ -213,7 +213,7 @@ fn call_name_symbol() { call_name_symbol_test(&v); } -fn call_name_symbol_test(v: &dyn VM) { +fn call_name_symbol_test(v: &dyn VM) { let addrs = create_accounts(v, 1, &TokenAmount::from_whole(10_000)); let sender = addrs[0]; diff --git a/test_vm/tests/evm_test.rs b/test_vm/tests/evm_test.rs index 301397323..3a82f82af 100644 --- a/test_vm/tests/evm_test.rs +++ b/test_vm/tests/evm_test.rs @@ -8,7 +8,7 @@ use fil_actors_runtime::{ test_utils::ETHACCOUNT_ACTOR_CODE_ID, test_utils::EVM_ACTOR_CODE_ID, EAM_ACTOR_ADDR, EAM_ACTOR_ID, }; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::ipld_block::IpldBlock; use fvm_ipld_encoding::{strict_bytes, BytesDe, RawBytes}; use fvm_shared::{address::Address, econ::TokenAmount}; @@ -46,7 +46,7 @@ fn evm_call() { evm_call_test(&v); } -fn evm_call_test(v: &dyn VM) { +fn evm_call_test(v: &dyn VM) { let account = create_accounts(v, 1, &TokenAmount::from_whole(10_000))[0]; let address = id_to_eth(account.id().unwrap()); let (client, _mock) = Provider::mocked(); @@ -102,7 +102,7 @@ fn evm_create() { evm_create_test(&v); } -fn evm_create_test(v: &dyn VM) { +fn evm_create_test(v: &dyn VM) { let account = create_accounts(v, 1, &TokenAmount::from_whole(10_000))[0]; let address = id_to_eth(account.id().unwrap()); @@ -251,10 +251,7 @@ fn evm_eth_create_external() { // Concrete use of TestVM is required here to run `set_actor` // Removing it will depend on https://github.com/filecoin-project/builtin-actors/issues/1297 -fn evm_eth_create_external_test( - v: &dyn VM, - _v_concrete: &TestVM, -) { +fn evm_eth_create_external_test(v: &dyn VM, _v_concrete: &TestVM) { // create the EthAccount let eth_bits = hex_literal::hex!("FEEDFACECAFEBEEF000000000000000000000000"); let eth_addr = Address::new_delegated(EAM_ACTOR_ID, ð_bits).unwrap(); @@ -318,7 +315,7 @@ fn evm_empty_initcode() { evm_empty_initcode_test(&v); } -fn evm_empty_initcode_test(v: &dyn VM) { +fn evm_empty_initcode_test(v: &dyn VM) { let account = create_accounts(v, 1, &TokenAmount::from_whole(10_000))[0]; let create_result = v .execute_message( @@ -346,7 +343,7 @@ fn evm_staticcall() { } #[allow(non_snake_case)] -fn evm_staticcall_test(v: &dyn VM) { +fn evm_staticcall_test(v: &dyn VM) { // test scenarios: // one hop: // A -> staticcall -> B (read) OK @@ -503,7 +500,7 @@ fn evm_delegatecall() { } #[allow(non_snake_case)] -fn evm_delegatecall_test(v: &dyn VM) { +fn evm_delegatecall_test(v: &dyn VM) { // test scenarios: // one hop: // A -> delegatecall -> B (read) OK @@ -644,7 +641,7 @@ fn evm_staticcall_delegatecall() { } #[allow(non_snake_case)] -fn evm_staticcall_delegatecall_test(v: &dyn VM) { +fn evm_staticcall_delegatecall_test(v: &dyn VM) { // test scenarios: // one hop: // A -> delegatecall -> B (read) OK @@ -752,7 +749,7 @@ fn evm_init_revert_data() { evm_init_revert_data_test(&v); } -fn evm_init_revert_data_test(v: &dyn VM) { +fn evm_init_revert_data_test(v: &dyn VM) { let account = create_accounts(v, 1, &TokenAmount::from_whole(10_000))[0]; let create_result = v .execute_message( diff --git a/test_vm/tests/extend_sectors_test.rs b/test_vm/tests/extend_sectors_test.rs index c83edb32e..78806e050 100644 --- a/test_vm/tests/extend_sectors_test.rs +++ b/test_vm/tests/extend_sectors_test.rs @@ -28,6 +28,7 @@ use test_vm::util::{ create_miner, cron_tick, expect_invariants, get_state, invariant_failure_patterns, market_add_balance, market_publish_deal, miner_precommit_sector, miner_prove_sector, sector_deadline, submit_windowed_post, verifreg_add_client, verifreg_add_verifier, + DynBlockstore, }; use test_vm::{TestVM, VM}; @@ -46,8 +47,8 @@ fn extend2_legacy_sector_with_deals() { } #[allow(clippy::too_many_arguments)] -fn extend( - v: &dyn VM, +fn extend( + v: &dyn VM, worker: Address, maddr: Address, deadline_index: u64, @@ -122,7 +123,7 @@ fn extend( // TODO: remove usage of _v_concrete which is currently required by mutate_state // https://github.com/filecoin-project/builtin-actors/issues/1297 fn extend_legacy_sector_with_deals_inner( - v: &dyn VM, + v: &dyn VM, do_extend2: bool, _v_concrete: &TestVM, ) { @@ -194,7 +195,10 @@ fn extend_legacy_sector_with_deals_inner( // inspect sector info let miner_state: MinerState = get_state(v, &miner_id).unwrap(); - let mut sector_info = miner_state.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let mut sector_info = miner_state + .get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap(); assert_eq!(180 * EPOCHS_IN_DAY, sector_info.expiration - sector_info.activation); assert_eq!(StoragePower::zero(), sector_info.deal_weight); // 0 space time assert_eq!( @@ -209,7 +213,8 @@ fn extend_legacy_sector_with_deals_inner( // Manually craft state to match legacy sectors _v_concrete.mutate_state(&miner_id, |st: &mut MinerState| { - let mut sectors = Sectors::load(*v.blockstore(), &st.sectors).unwrap(); + let store = &DynBlockstore::wrap(v.blockstore()); + let mut sectors = Sectors::load(store, &st.sectors).unwrap(); sectors.store(vec![sector_info.clone()]).unwrap(); st.sectors = sectors.amt.flush().unwrap(); }); @@ -274,7 +279,10 @@ fn extend_legacy_sector_with_deals_inner( ); let miner_state: MinerState = get_state(v, &miner_id).unwrap(); - sector_info = miner_state.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + sector_info = miner_state + .get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap(); assert_eq!(180 * 2 * EPOCHS_IN_DAY, sector_info.expiration - sector_info.activation); assert_eq!(initial_deal_weight, sector_info.deal_weight); // 0 space time, unchanged assert_eq!(&initial_verified_deal_weight / 2, sector_info.verified_deal_weight); @@ -315,7 +323,10 @@ fn extend_legacy_sector_with_deals_inner( ); let miner_state: MinerState = get_state(v, &miner_id).unwrap(); - let sector_info = miner_state.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let sector_info = miner_state + .get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap(); assert_eq!(180 * 3 * EPOCHS_IN_DAY, sector_info.expiration - sector_info.activation); // 0 space time, unchanged assert_eq!(initial_deal_weight, sector_info.deal_weight); @@ -638,7 +649,7 @@ fn commit_sector_with_max_duration_deal() { commit_sector_with_max_duration_deal_test(&v); } -fn commit_sector_with_max_duration_deal_test(v: &dyn VM) { +fn commit_sector_with_max_duration_deal_test(v: &dyn VM) { 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]); @@ -721,6 +732,9 @@ fn commit_sector_with_max_duration_deal_test(v: &dyn VM) { ); // inspect sector info let miner_state: MinerState = get_state(v, &miner_id).unwrap(); - let sector_info = miner_state.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let sector_info = miner_state + .get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap(); assert_eq!(deal_lifetime, sector_info.expiration - sector_info.activation); } diff --git a/test_vm/tests/init_test.rs b/test_vm/tests/init_test.rs index 301ab53d7..68702b576 100644 --- a/test_vm/tests/init_test.rs +++ b/test_vm/tests/init_test.rs @@ -5,12 +5,12 @@ use fil_actors_runtime::{ test_utils::{EAM_ACTOR_CODE_ID, MULTISIG_ACTOR_CODE_ID, PLACEHOLDER_ACTOR_CODE_ID}, EAM_ACTOR_ADDR, EAM_ACTOR_ID, INIT_ACTOR_ADDR, }; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::{address::Address, econ::TokenAmount, error::ExitCode, METHOD_SEND}; use num_traits::Zero; use test_vm::{actor, util::serialize_ok, TestVM, FIRST_TEST_USER_ADDR, TEST_FAUCET_ADDR, VM}; -fn assert_placeholder_actor(exp_bal: TokenAmount, v: &dyn VM, addr: Address) { +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!(*PLACEHOLDER_ACTOR_CODE_ID, act.code); diff --git a/test_vm/tests/market_miner_withdrawal_test.rs b/test_vm/tests/market_miner_withdrawal_test.rs index 04c941707..7ab0ba046 100644 --- a/test_vm/tests/market_miner_withdrawal_test.rs +++ b/test_vm/tests/market_miner_withdrawal_test.rs @@ -4,7 +4,6 @@ use fil_actor_miner::Method as MinerMethod; use fil_actor_miner::WithdrawBalanceParams as MinerWithdrawBalanceParams; use fil_actors_runtime::test_utils::{MARKET_ACTOR_CODE_ID, MINER_ACTOR_CODE_ID}; use fil_actors_runtime::STORAGE_MARKET_ACTOR_ADDR; -use fvm_ipld_blockstore::Blockstore; use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::RawBytes; use fvm_shared::address::Address; @@ -17,6 +16,7 @@ use fvm_shared::METHOD_SEND; use test_vm::util::{apply_code, apply_ok, create_accounts, create_miner}; use test_vm::Actor; use test_vm::TestVM; +use test_vm::VM; #[cfg(test)] mod market_tests { @@ -25,11 +25,16 @@ mod market_tests { #[test] fn withdraw_all_funds() { let store = MemoryBlockstore::new(); - let (v, caller) = market_setup(&store); + let v = TestVM::::new_with_singletons(&store); + withdraw_all_funds_test(&v); + } + + fn withdraw_all_funds_test(v: &dyn VM) { + let caller = market_setup(v); let three_fil = TokenAmount::from_whole(3); assert_add_collateral_and_withdraw( - &v, + v, three_fil.clone(), three_fil.clone(), three_fil, @@ -41,13 +46,19 @@ mod market_tests { #[test] fn withdraw_as_much_as_possible() { let store = MemoryBlockstore::new(); - let (v, caller) = market_setup(&store); + let v = TestVM::::new_with_singletons(&store); + + withdraw_as_much_as_possible_test(&v); + } + + fn withdraw_as_much_as_possible_test(v: &dyn VM) { + let caller = market_setup(v); // Add 2 FIL of collateral and attempt to withdraw 3 let two_fil = TokenAmount::from_whole(2); let three_fil = TokenAmount::from_whole(3); assert_add_collateral_and_withdraw( - &v, + v, two_fil.clone(), two_fil, three_fil, @@ -59,12 +70,17 @@ mod market_tests { #[test] fn withdraw_0() { let store = MemoryBlockstore::new(); - let (v, caller) = market_setup(&store); + let v = TestVM::::new_with_singletons(&store); + withdraw_0_test(&v); + } + + fn withdraw_0_test(v: &dyn VM) { + let caller = market_setup(v); // Add 0 FIL of collateral and attempt to withdraw 3 let three_fil = TokenAmount::from_whole(3); assert_add_collateral_and_withdraw( - &v, + v, TokenAmount::zero(), TokenAmount::zero(), three_fil, @@ -81,11 +97,17 @@ mod miner_tests { #[test] fn withdraw_all_funds() { let store = MemoryBlockstore::new(); - let (v, _, owner, m_addr) = miner_setup(&store); + let v = TestVM::::new_with_singletons(&store); + + withdraw_all_funds_test(&v); + } + + fn withdraw_all_funds_test(v: &dyn VM) { + let (_, owner, m_addr) = miner_setup(v); let three_fil = TokenAmount::from_whole(3); assert_add_collateral_and_withdraw( - &v, + v, three_fil.clone(), three_fil.clone(), three_fil, @@ -97,21 +119,29 @@ mod miner_tests { #[test] fn withdraw_as_much_as_possible() { let store = MemoryBlockstore::new(); - let (v, _, owner, m_addr) = miner_setup(&store); + let v = TestVM::::new_with_singletons(&store); + withdraw_as_much_as_possible_test(&v); + } + fn withdraw_as_much_as_possible_test(v: &dyn VM) { + let (_, owner, m_addr) = miner_setup(v); let two_fil = TokenAmount::from_whole(2); let three_fil = TokenAmount::from_whole(3); - assert_add_collateral_and_withdraw(&v, two_fil.clone(), two_fil, three_fil, m_addr, owner); + assert_add_collateral_and_withdraw(v, two_fil.clone(), two_fil, three_fil, m_addr, owner); } #[test] fn withdraw_0() { let store = MemoryBlockstore::new(); - let (v, _, owner, m_addr) = miner_setup(&store); + let v = TestVM::::new_with_singletons(&store); + withdraw_0_test(&v); + } + fn withdraw_0_test(v: &dyn VM) { + let (_, owner, m_addr) = miner_setup(v); let three_fil = TokenAmount::from_whole(3); assert_add_collateral_and_withdraw( - &v, + v, TokenAmount::zero(), TokenAmount::zero(), three_fil, @@ -123,14 +153,18 @@ mod miner_tests { #[test] fn withdraw_from_non_owner_address_fails() { let store = MemoryBlockstore::new(); - let (v, worker, _, m_addr) = miner_setup(&store); + let v = TestVM::::new_with_singletons(&store); + withdraw_from_non_owner_address_fails_test(&v) + } + fn withdraw_from_non_owner_address_fails_test(v: &dyn VM) { + let (ref worker, _, ref miner) = miner_setup(v); let one_fil = TokenAmount::from_whole(1); let params = MinerWithdrawBalanceParams { amount_requested: one_fil }; apply_code( - &v, - &worker, - &m_addr, + v, + worker, + miner, &TokenAmount::zero(), MinerMethod::WithdrawBalance as u64, Some(params), @@ -143,8 +177,8 @@ mod miner_tests { // 1. Add collateral to escrow address // 2. Send a withdraw message attempting to remove `requested` funds // 3. Assert correct return value and actor balance transfer -fn assert_add_collateral_and_withdraw( - v: &TestVM, +fn assert_add_collateral_and_withdraw( + v: &dyn VM, collateral: TokenAmount, expected_withdrawn: TokenAmount, requested: TokenAmount, @@ -220,34 +254,29 @@ fn assert_add_collateral_and_withdraw( assert_eq!(caller_initial_balance, c.balance); } -fn require_actor(v: &TestVM, addr: Address) -> Actor { - v.get_actor(&addr).unwrap() +fn require_actor(v: &dyn VM, addr: Address) -> Actor { + v.actor(&addr).unwrap() } -fn market_setup(store: &'_ MemoryBlockstore) -> (TestVM, Address) { - let v = TestVM::::new_with_singletons(store); +fn market_setup(v: &dyn VM) -> Address { let initial_balance = TokenAmount::from_whole(6); - let addrs = create_accounts(&v, 1, &initial_balance); - let caller = addrs[0]; - (v, caller) + let addrs = create_accounts(v, 1, &initial_balance); + addrs[0] } -fn miner_setup( - store: &'_ MemoryBlockstore, -) -> (TestVM, Address, Address, Address) { - let v = TestVM::::new_with_singletons(store); +fn miner_setup(v: &dyn VM) -> (Address, Address, Address) { let initial_balance = TokenAmount::from_whole(10_000); - let addrs = create_accounts(&v, 2, &initial_balance); + let addrs = create_accounts(v, 2, &initial_balance); let (worker, owner) = (addrs[0], addrs[1]); // create miner let (m_addr, _) = create_miner( - &v, + v, &owner, &worker, RegisteredPoStProof::StackedDRGWindow32GiBV1P1, &TokenAmount::zero(), ); - (v, worker, owner, m_addr) + (worker, owner, m_addr) } diff --git a/test_vm/tests/multisig_test.rs b/test_vm/tests/multisig_test.rs index 2d71e6b4d..d96503179 100644 --- a/test_vm/tests/multisig_test.rs +++ b/test_vm/tests/multisig_test.rs @@ -6,7 +6,7 @@ use fil_actor_multisig::{ use fil_actors_runtime::cbor::serialize; use fil_actors_runtime::test_utils::*; use fil_actors_runtime::{make_map_with_root, INIT_ACTOR_ADDR, SYSTEM_ACTOR_ADDR}; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::RawBytes; use fvm_shared::address::Address; use fvm_shared::bigint::Zero; @@ -18,7 +18,9 @@ use std::collections::HashSet; use std::iter::FromIterator; use test_vm::expects::Expect; use test_vm::trace::ExpectInvocation; -use test_vm::util::{apply_code, apply_ok, assert_invariants, create_accounts, get_state}; +use test_vm::util::{ + apply_code, apply_ok, assert_invariants, create_accounts, get_state, DynBlockstore, +}; use test_vm::{TestVM, VM}; #[test] @@ -32,7 +34,7 @@ fn proposal_hash() { assert_invariants(&v) } -fn proposal_hash_test(v: &dyn VM, addrs: &[Address]) -> TokenAmount { +fn proposal_hash_test(v: &dyn VM, addrs: &[Address]) -> TokenAmount { let alice = addrs[0]; let bob = addrs[1]; let msig_addr = create_msig(v, addrs, 2); @@ -61,7 +63,9 @@ fn proposal_hash_test(v: &dyn VM, addrs: &[Address]) -> Toke approved: vec![alice], params: RawBytes::default(), }; - let wrong_hash = compute_proposal_hash(&wrong_tx, &MockRuntime::new(*v.blockstore())).unwrap(); + let wrong_hash = + compute_proposal_hash(&wrong_tx, &MockRuntime::new(&DynBlockstore::wrap(v.blockstore()))) + .unwrap(); let wrong_approval_params = TxnIDParams { id: TxnID(0), proposal_hash: wrong_hash.to_vec() }; apply_code( v, @@ -81,7 +85,8 @@ fn proposal_hash_test(v: &dyn VM, addrs: &[Address]) -> Toke params: RawBytes::default(), }; let correct_hash = - compute_proposal_hash(&correct_tx, &MockRuntime::new(*v.blockstore())).unwrap(); + compute_proposal_hash(&correct_tx, &MockRuntime::new(&DynBlockstore::wrap(v.blockstore()))) + .unwrap(); let correct_approval_params = TxnIDParams { id: TxnID(0), proposal_hash: correct_hash.to_vec() }; apply_ok( @@ -186,7 +191,7 @@ fn swap_self_1_of_2() { swap_self_1_of_2_test(&v); } -fn swap_self_1_of_2_test(v: &dyn VM) { +fn swap_self_1_of_2_test(v: &dyn VM) { let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let (alice, bob, chuck) = (addrs[0], addrs[1], addrs[2]); let msig_addr = create_msig(v, &[alice, bob], 1); @@ -218,7 +223,7 @@ fn swap_self_2_of_3() { swap_self_2_of_3_test(&v); } -fn swap_self_2_of_3_test(v: &dyn VM) { +fn swap_self_2_of_3_test(v: &dyn VM) { let addrs = create_accounts(v, 4, &TokenAmount::from_whole(10_000)); let (alice, bob, chuck, dinesh) = (addrs[0], addrs[1], addrs[2], addrs[3]); @@ -289,7 +294,7 @@ fn swap_self_2_of_3_test(v: &dyn VM) { assert_invariants(v) } -fn create_msig(v: &dyn VM, signers: &[Address], threshold: u64) -> Address { +fn create_msig(v: &dyn VM, signers: &[Address], threshold: u64) -> Address { assert!(!signers.is_empty()); let msig_ctor_params = serialize( &fil_actor_multisig::ConstructorParams { @@ -317,13 +322,10 @@ fn create_msig(v: &dyn VM, signers: &[Address], threshold: u msig_ctor_ret.id_address } -fn check_txs( - v: &dyn VM, - msig_addr: Address, - mut expect_txns: Vec<(TxnID, Transaction)>, -) { +fn check_txs(v: &dyn VM, msig_addr: Address, mut expect_txns: Vec<(TxnID, Transaction)>) { let st: MsigState = get_state(v, &msig_addr).unwrap(); - let ptx = make_map_with_root::<_, Transaction>(&st.pending_txs, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let ptx = make_map_with_root::<_, Transaction>(&st.pending_txs, &store).unwrap(); let mut actual_txns = Vec::new(); ptx.for_each(|k, txn: &Transaction| { let id = i64::decode_var(k).unwrap().0; diff --git a/test_vm/tests/power_scenario_tests.rs b/test_vm/tests/power_scenario_tests.rs index 17cd6c9ee..e46269786 100644 --- a/test_vm/tests/power_scenario_tests.rs +++ b/test_vm/tests/power_scenario_tests.rs @@ -7,7 +7,7 @@ use fil_actor_power::{CreateMinerParams, Method as PowerMethod}; use fil_actors_runtime::runtime::Policy; use fil_actors_runtime::test_utils::make_sealed_cid; use fil_actors_runtime::{CRON_ACTOR_ADDR, INIT_ACTOR_ADDR, STORAGE_POWER_ACTOR_ADDR}; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::{BytesDe, RawBytes}; use fvm_shared::address::Address; @@ -32,7 +32,7 @@ fn power_create_miner() { power_create_miner_test(&v); } -fn power_create_miner_test(v: &dyn VM) { +fn power_create_miner_test(v: &dyn VM) { let owner = Address::new_bls(&[1; fvm_shared::address::BLS_PUB_LEN]).unwrap(); v.execute_message( &TEST_FAUCET_ADDR, diff --git a/test_vm/tests/publish_deals_test.rs b/test_vm/tests/publish_deals_test.rs index 57bea3ee7..37b3f6c11 100644 --- a/test_vm/tests/publish_deals_test.rs +++ b/test_vm/tests/publish_deals_test.rs @@ -1,4 +1,3 @@ -use fvm_ipld_blockstore::Blockstore; use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::ipld_block::IpldBlock; use fvm_shared::address::Address; @@ -131,7 +130,7 @@ fn psd_mismatched_provider() { psd_mismatched_provider_test(&v, a, deal_start); } -fn psd_mismatched_provider_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_mismatched_provider_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts); @@ -157,7 +156,7 @@ fn psd_bad_piece_size() { psd_bad_piece_size_test(&v, a, deal_start); } -fn psd_bad_piece_size_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_bad_piece_size_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); @@ -184,7 +183,7 @@ fn psd_start_time_in_past() { psd_start_time_in_past_test(&v, a, deal_start); } -fn psd_start_time_in_past_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_start_time_in_past_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); @@ -206,11 +205,7 @@ fn psd_client_address_cannot_be_resolved() { psd_client_address_cannot_be_resolved_test(&v, a, deal_start); } -fn psd_client_address_cannot_be_resolved_test( - v: &dyn VM, - a: Addrs, - deal_start: i64, -) { +fn psd_client_address_cannot_be_resolved_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts); let bad_client = Address::new_id(5_000_000); @@ -231,7 +226,7 @@ fn psd_no_client_lockup() { psd_no_client_lockup_test(&v, a, deal_start); } -fn psd_no_client_lockup_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_no_client_lockup_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts); batcher.stage(a.cheap_client, a.maddr); @@ -252,11 +247,7 @@ fn psd_not_enough_client_lockup_for_batch() { psd_not_enough_client_lockup_for_batch_test(&v, a, deal_start); } -fn psd_not_enough_client_lockup_for_batch_test( - v: &dyn VM, - a: Addrs, - deal_start: i64, -) { +fn psd_not_enough_client_lockup_for_batch_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); @@ -292,11 +283,7 @@ fn psd_not_enough_provider_lockup_for_batch() { psd_not_enough_provider_lockup_for_batch_test(&v, deal_start, a); } -fn psd_not_enough_provider_lockup_for_batch_test( - v: &dyn VM, - deal_start: i64, - a: Addrs, -) { +fn psd_not_enough_provider_lockup_for_batch_test(v: &dyn VM, deal_start: i64, a: Addrs) { // note different seed, different address let cheap_worker = create_accounts_seeded(v, 1, &TokenAmount::from_whole(10_000), 444)[0]; let cheap_maddr = create_miner( @@ -337,7 +324,7 @@ fn psd_duplicate_deal_in_batch() { psd_duplicate_deal_in_batch_test(&v, a, deal_start); } -fn psd_duplicate_deal_in_batch_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_duplicate_deal_in_batch_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts); @@ -369,7 +356,7 @@ fn psd_duplicate_deal_in_state() { psd_duplicate_deal_in_state_test(&v, a, deal_start); } -fn psd_duplicate_deal_in_state_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_duplicate_deal_in_state_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); @@ -399,11 +386,7 @@ fn psd_verified_deal_fails_getting_datacap() { psd_verified_deal_fails_getting_datacap_test(&v, a, deal_start); } -fn psd_verified_deal_fails_getting_datacap_test( - v: &dyn VM, - a: Addrs, - deal_start: i64, -) { +fn psd_verified_deal_fails_getting_datacap_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); @@ -435,11 +418,7 @@ fn psd_random_assortment_of_failures() { psd_random_assortment_of_failures_test(&v, a, deal_start); } -fn psd_random_assortment_of_failures_test( - v: &dyn VM, - a: Addrs, - deal_start: i64, -) { +fn psd_random_assortment_of_failures_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); // Add one lifetime cost to cheap_client's market balance but attempt to make 3 deals @@ -502,7 +481,7 @@ fn psd_all_deals_are_bad() { psd_all_deals_are_bad_test(&v, a, deal_start); } -fn psd_all_deals_are_bad_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_all_deals_are_bad_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); let bad_client = Address::new_id(1000); @@ -532,7 +511,7 @@ fn psd_bad_sig() { psd_bad_sig_test(&v, a, deal_start); } -fn psd_bad_sig_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_bad_sig_test(v: &dyn VM, a: Addrs, deal_start: i64) { let DealOptions { price_per_epoch, provider_collateral, client_collateral, .. } = DealOptions::default(); let deal_label = "deal0".to_string(); @@ -610,7 +589,7 @@ fn psd_all_deals_are_good() { all_deals_are_good_test(&v, a, deal_start); } -fn all_deals_are_good_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn all_deals_are_good_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts); @@ -635,11 +614,7 @@ fn psd_valid_deals_with_ones_longer_than_540() { psd_valid_deals_with_ones_longer_than_540_test(&v, a, deal_start); } -fn psd_valid_deals_with_ones_longer_than_540_test( - v: &dyn VM, - a: Addrs, - deal_start: i64, -) { +fn psd_valid_deals_with_ones_longer_than_540_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); @@ -670,7 +645,7 @@ fn psd_deal_duration_too_long() { psd_deal_duration_too_long_test(&v, a, deal_start); } -fn psd_deal_duration_too_long_test(v: &dyn VM, a: Addrs, deal_start: i64) { +fn psd_deal_duration_too_long_test(v: &dyn VM, a: Addrs, deal_start: i64) { let opts = DealOptions { deal_start, ..DealOptions::default() }; let mut batcher = DealBatcher::new(v, opts.clone()); diff --git a/test_vm/tests/replica_update_test.rs b/test_vm/tests/replica_update_test.rs index 3ef38c2d9..6fb2e3eda 100644 --- a/test_vm/tests/replica_update_test.rs +++ b/test_vm/tests/replica_update_test.rs @@ -18,7 +18,7 @@ use fil_actors_runtime::{ Array, CRON_ACTOR_ADDR, EPOCHS_IN_DAY, STORAGE_MARKET_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, }; use fvm_ipld_bitfield::BitField; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::RawBytes; use fvm_shared::address::Address; use fvm_shared::bigint::{BigInt, Zero}; @@ -39,6 +39,7 @@ use test_vm::util::{ get_network_stats, get_state, invariant_failure_patterns, make_bitfield, market_publish_deal, miner_balance, miner_power, precommit_sectors, prove_commit_sectors, sector_info, submit_invalid_post, submit_windowed_post, verifreg_add_client, verifreg_add_verifier, + DynBlockstore, }; use test_vm::TestVM; @@ -71,8 +72,8 @@ fn replica_update_full_path_success(v2: bool) { } #[allow(clippy::too_many_arguments)] -fn replica_update_full_path_success_test( - v: &dyn VM, +fn replica_update_full_path_success_test( + v: &dyn VM, sector_info: SectorOnChainInfo, miner_id: Address, worker: Address, @@ -134,7 +135,7 @@ fn upgrade_and_miss_post(v2: bool) { let store = &MemoryBlockstore::new(); let (v, sector_info, worker, miner_id, deadline_index, partition_index, sector_size) = create_miner_and_upgrade_sector(store, v2); - upgrade_and_miss_post_test::( + upgrade_and_miss_post_test( &v, sector_info, miner_id, @@ -147,8 +148,8 @@ fn upgrade_and_miss_post(v2: bool) { } #[allow(clippy::too_many_arguments)] -fn upgrade_and_miss_post_test( - v: &dyn VM, +fn upgrade_and_miss_post_test( + v: &dyn VM, sector_info: SectorOnChainInfo, miner_id: Address, deadline_index: u64, @@ -209,7 +210,7 @@ fn prove_replica_update_multi_dline() { prove_replica_update_multi_dline_test(&v); } -fn prove_replica_update_multi_dline_test(v: &dyn VM) { +fn prove_replica_update_multi_dline_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(1_000_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -355,7 +356,7 @@ fn immutable_deadline_failure() { immutable_deadline_failure_test(&v); } -fn immutable_deadline_failure_test(v: &dyn VM) { +fn immutable_deadline_failure_test(v: &dyn VM) { let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; @@ -410,7 +411,7 @@ fn unhealthy_sector_failure() { unhealthy_sector_failure_test(&v); } -fn unhealthy_sector_failure_test(v: &dyn VM) { +fn unhealthy_sector_failure_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -469,7 +470,7 @@ fn terminated_sector_failure() { terminated_sector_failure_test(&v); } -fn terminated_sector_failure_test(v: &dyn VM) { +fn terminated_sector_failure_test(v: &dyn VM) { let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; @@ -539,7 +540,7 @@ fn bad_batch_size_failure() { bad_batch_size_failure_test(&v); } -fn bad_batch_size_failure_test(v: &dyn VM) { +fn bad_batch_size_failure_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -599,8 +600,8 @@ fn no_dispute_after_upgrade() { nodispute_after_upgrade_test(&v, deadline_index, worker, miner_id); } -fn nodispute_after_upgrade_test( - v: &dyn VM, +fn nodispute_after_upgrade_test( + v: &dyn VM, deadline_index: u64, worker: Address, miner_id: Address, @@ -635,8 +636,8 @@ fn upgrade_bad_post_dispute() { ); } -fn upgrade_bad_post_dispute_test( - v: &dyn VM, +fn upgrade_bad_post_dispute_test( + v: &dyn VM, sector_info: SectorOnChainInfo, miner_id: Address, worker: Address, @@ -671,7 +672,7 @@ fn bad_post_upgrade_dispute() { bad_post_upgrade_dispute_test(&v); } -fn bad_post_upgrade_dispute_test(v: &dyn VM) { +fn bad_post_upgrade_dispute_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -762,8 +763,8 @@ fn terminate_after_upgrade() { ); } -fn terminate_after_upgrade_test( - v: &dyn VM, +fn terminate_after_upgrade_test( + v: &dyn VM, sector_info: SectorOnChainInfo, worker: Address, miner_id: Address, @@ -822,7 +823,7 @@ fn extend_after_upgrade() { st.sectors = sectors.amt.flush().unwrap(); }); - extend_after_upgrade_test::( + extend_after_upgrade_test( &v, miner_id, store, @@ -834,8 +835,8 @@ fn extend_after_upgrade() { } #[allow(clippy::too_many_arguments)] -fn extend_after_upgrade_test( - v: &dyn VM, +fn extend_after_upgrade_test( + v: &dyn VM, miner_id: Address, store: &MemoryBlockstore, worker: Address, @@ -881,7 +882,7 @@ fn wrong_deadline_index_failure() { wrong_deadline_index_failure_test(&v); } -fn wrong_deadline_index_failure_test(v: &dyn VM) { +fn wrong_deadline_index_failure_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -944,7 +945,7 @@ fn wrong_partition_index_failure() { wrong_partition_index_failure_test(&v); } -fn wrong_partition_index_failure_test(v: &dyn VM) { +fn wrong_partition_index_failure_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -1006,7 +1007,7 @@ fn deal_included_in_multiple_sectors_failure() { deal_included_in_multiple_sectors_failure_test(&v); } -fn deal_included_in_multiple_sectors_failure_test(v: &dyn VM) { +fn deal_included_in_multiple_sectors_failure_test(v: &dyn VM) { let policy = Policy::default(); let addrs = create_accounts(v, 1, &TokenAmount::from_whole(100_000)); let (worker, owner) = (addrs[0], addrs[0]); @@ -1137,7 +1138,7 @@ fn replica_update_verified_deal() { replica_update_verified_deal_test(&v); } -fn replica_update_verified_deal_test(v: &dyn VM) { +fn replica_update_verified_deal_test(v: &dyn VM) { 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 seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; @@ -1252,7 +1253,7 @@ fn replica_update_verified_deal_max_term_violated() { replica_update_verified_deal_max_term_violated_test(&v); } -fn replica_update_verified_deal_max_term_violated_test(v: &dyn VM) { +fn replica_update_verified_deal_max_term_violated_test(v: &dyn VM) { 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 seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; @@ -1396,8 +1397,8 @@ fn create_miner_and_upgrade_sector( // - fastforwarding to its Proving period and PoSting it // - fastforwarding out of the proving period into a new deadline // This method assumes that this is a miners first and only sector -fn create_sector( - v: &dyn VM, +fn create_sector( + v: &dyn VM, worker: Address, maddr: Address, sector_number: SectorNumber, @@ -1439,7 +1440,8 @@ fn create_sector( // not active until post assert!(!check_sector_active(v, &maddr, sector_number)); let m_st: MinerState = get_state(v, &maddr).unwrap(); - let sector = m_st.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let sector = + m_st.get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number).unwrap().unwrap(); let sector_power = power_for_sector(seal_proof.sector_size().unwrap(), §or); submit_windowed_post(v, &worker, &maddr, dline_info, p_idx, Some(sector_power)); @@ -1458,9 +1460,9 @@ fn create_sector( (d_idx, p_idx) } -fn create_deals( +fn create_deals( num_deals: u32, - v: &dyn VM, + v: &dyn VM, client: Address, worker: Address, maddr: Address, @@ -1468,9 +1470,9 @@ fn create_deals( create_deals_frac(num_deals, v, client, worker, maddr, 1, false, 180 * EPOCHS_IN_DAY) } -fn create_verified_deals( +fn create_verified_deals( num_deals: u32, - v: &dyn VM, + v: &dyn VM, client: Address, worker: Address, maddr: Address, @@ -1480,9 +1482,9 @@ fn create_verified_deals( } #[allow(clippy::too_many_arguments)] -fn create_deals_frac( +fn create_deals_frac( num_deals: u32, - v: &dyn VM, + v: &dyn VM, client: Address, worker: Address, maddr: Address, diff --git a/test_vm/tests/terminate_test.rs b/test_vm/tests/terminate_test.rs index 2e5b445cd..b565d6c5d 100644 --- a/test_vm/tests/terminate_test.rs +++ b/test_vm/tests/terminate_test.rs @@ -14,7 +14,7 @@ use fil_actors_runtime::{ test_utils::*, CRON_ACTOR_ADDR, STORAGE_MARKET_ACTOR_ADDR, STORAGE_POWER_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR, }; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; use fvm_shared::error::ExitCode; @@ -28,7 +28,7 @@ use test_vm::util::{ advance_by_deadline_to_epoch, advance_by_deadline_to_epoch_while_proving, advance_to_proving_deadline, apply_ok, create_accounts, create_miner, expect_invariants, get_state, invariant_failure_patterns, make_bitfield, market_publish_deal, miner_balance, - submit_windowed_post, verifreg_add_verifier, + submit_windowed_post, verifreg_add_verifier, DynBlockstore, }; use test_vm::{TestVM, VM}; @@ -39,7 +39,7 @@ fn terminate_sectors() { terminate_sectors_test(&v); } -fn terminate_sectors_test(v: &dyn VM) { +fn terminate_sectors_test(v: &dyn VM) { let addrs = create_accounts(v, 4, &TokenAmount::from_whole(10_000)); let (owner, verifier, unverified_client, verified_client) = (addrs[0], addrs[1], addrs[2], addrs[3]); @@ -160,7 +160,8 @@ fn terminate_sectors_test(v: &dyn VM) { .unwrap(); assert_eq!(ExitCode::OK, res.code); let st: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); - let deal_states = DealMetaArray::load(&st.states, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let deal_states = DealMetaArray::load(&st.states, &store).unwrap(); for id in deal_ids.iter() { // deals are pending and don't yet have deal states let state = deal_states.get(*id).unwrap(); @@ -209,7 +210,8 @@ fn terminate_sectors_test(v: &dyn VM) { let (dline_info, p_idx) = advance_to_proving_deadline(v, &miner_id_addr, sector_number); let d_idx = dline_info.index; let st: MinerState = get_state(v, &miner_id_addr).unwrap(); - let sector = st.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let sector = + st.get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number).unwrap().unwrap(); let sector_power = power_for_sector(seal_proof.sector_size().unwrap(), §or); submit_windowed_post(v, &worker, &miner_id_addr, dline_info, p_idx, Some(sector_power.clone())); v.set_epoch(dline_info.last()); @@ -238,7 +240,8 @@ fn terminate_sectors_test(v: &dyn VM) { // market cron updates deal states indication deals are no longer pending let st: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); - let deal_states = DealMetaArray::load(&st.states, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let deal_states = DealMetaArray::load(&st.states, &store).unwrap(); for id in deal_ids.iter() { let state = deal_states.get(*id).unwrap().unwrap(); assert!(state.last_updated_epoch > 0); @@ -292,7 +295,8 @@ fn terminate_sectors_test(v: &dyn VM) { // termination slashes deals in market state let termination_epoch = v.epoch(); let st: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); - let deal_states = DealMetaArray::load(&st.states, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let deal_states = DealMetaArray::load(&st.states, &store).unwrap(); for id in deal_ids.iter() { let state = deal_states.get(*id).unwrap().unwrap(); assert!(state.last_updated_epoch > 0); diff --git a/test_vm/tests/verified_claim_test.rs b/test_vm/tests/verified_claim_test.rs index 106e43826..fb56ead1d 100644 --- a/test_vm/tests/verified_claim_test.rs +++ b/test_vm/tests/verified_claim_test.rs @@ -1,4 +1,4 @@ -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; use fvm_shared::piece::PaddedPieceSize; @@ -34,6 +34,7 @@ use test_vm::util::{ market_publish_deal, miner_extend_sector_expiration2, miner_precommit_sector, miner_prove_sector, sector_deadline, submit_windowed_post, verifreg_add_client, verifreg_add_verifier, verifreg_extend_claim_terms, verifreg_remove_expired_allocations, + DynBlockstore, }; use test_vm::{TestVM, VM}; @@ -47,7 +48,7 @@ fn verified_claim_scenario() { verified_claim_scenario_test(&v); } -fn verified_claim_scenario_test(v: &dyn VM) { +fn verified_claim_scenario_test(v: &dyn VM) { let addrs = create_accounts(v, 4, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, verifier, verified_client, verified_client2) = @@ -114,7 +115,10 @@ fn verified_claim_scenario_test(v: &dyn VM) { // Verify sector info let miner_state: MinerState = get_state(v, &miner_id).unwrap(); - let sector_info = miner_state.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let sector_info = miner_state + .get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap(); assert_eq!(sector_term, sector_info.expiration - sector_info.activation); assert_eq!(DealWeight::zero(), sector_info.deal_weight); // Verified weight is sector term * 32 GiB, using simple QAP @@ -123,7 +127,8 @@ fn verified_claim_scenario_test(v: &dyn VM) { // Verify deal state. let market_state: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); - let deal_states = DealMetaArray::load(&market_state.states, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let deal_states = DealMetaArray::load(&market_state.states, &store).unwrap(); let deal_state = deal_states.get(deals[0]).unwrap().unwrap(); let claim_id = deal_state.verified_claim; assert_ne!(0, claim_id); @@ -132,17 +137,26 @@ fn verified_claim_scenario_test(v: &dyn VM) { let datacap_state: DatacapState = get_state(v, &DATACAP_TOKEN_ACTOR_ADDR).unwrap(); assert_eq!( TokenAmount::from_whole(datacap.clone()) - TokenAmount::from_whole(deal_size), // Spent deal size - datacap_state.token.get_balance(*v.blockstore(), verified_client.id().unwrap()).unwrap() + datacap_state + .token + .get_balance(&DynBlockstore::wrap(v.blockstore()), verified_client.id().unwrap()) + .unwrap() ); assert_eq!( TokenAmount::from_whole(datacap.clone()), // Nothing spent - datacap_state.token.get_balance(*v.blockstore(), verified_client2.id().unwrap()).unwrap() + datacap_state + .token + .get_balance(&DynBlockstore::wrap(v.blockstore()), verified_client2.id().unwrap()) + .unwrap() ); assert_eq!( TokenAmount::zero(), // Burnt when the allocation was claimed datacap_state .token - .get_balance(*v.blockstore(), VERIFIED_REGISTRY_ACTOR_ADDR.id().unwrap()) + .get_balance( + &DynBlockstore::wrap(v.blockstore()), + VERIFIED_REGISTRY_ACTOR_ADDR.id().unwrap() + ) .unwrap() ); assert_eq!( @@ -152,7 +166,8 @@ fn verified_claim_scenario_test(v: &dyn VM) { // Verify claim state let verifreg_state: VerifregState = get_state(v, &VERIFIED_REGISTRY_ACTOR_ADDR).unwrap(); - let mut claims = verifreg_state.load_claims(*v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let mut claims = verifreg_state.load_claims(&store).unwrap(); let claim = claims.get(miner_id.id().unwrap(), claim_id).unwrap().unwrap(); assert_eq!(sector_number, claim.sector); assert_eq!( @@ -185,7 +200,8 @@ fn verified_claim_scenario_test(v: &dyn VM) { // Verify miner power let power_state: PowerState = get_state(v, &STORAGE_POWER_ACTOR_ADDR).unwrap(); - let power_claim = power_state.get_claim(*v.blockstore(), &miner_id).unwrap().unwrap(); + let power_claim = + power_state.get_claim(&DynBlockstore::wrap(v.blockstore()), &miner_id).unwrap().unwrap(); assert_eq!(power_claim.raw_byte_power, expected_power.raw); assert_eq!(power_claim.quality_adj_power, expected_power.qa); @@ -280,7 +296,10 @@ fn verified_claim_scenario_test(v: &dyn VM) { // Verify sector info let miner_state: MinerState = get_state(v, &miner_id).unwrap(); - let sector_info = miner_state.get_sector(*v.blockstore(), sector_number).unwrap().unwrap(); + let sector_info = miner_state + .get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number) + .unwrap() + .unwrap(); assert_eq!(extended_expiration_2, sector_info.expiration); assert_eq!(DealWeight::zero(), sector_info.deal_weight); assert_eq!(DealWeight::zero(), sector_info.verified_deal_weight); @@ -290,17 +309,26 @@ fn verified_claim_scenario_test(v: &dyn VM) { let datacap_state: DatacapState = get_state(v, &DATACAP_TOKEN_ACTOR_ADDR).unwrap(); assert_eq!( TokenAmount::from_whole(datacap.clone()) - TokenAmount::from_whole(deal_size), // Spent deal size - datacap_state.token.get_balance(*v.blockstore(), verified_client.id().unwrap()).unwrap() + datacap_state + .token + .get_balance(&DynBlockstore::wrap(v.blockstore()), verified_client.id().unwrap()) + .unwrap() ); assert_eq!( TokenAmount::from_whole(datacap.clone()) - TokenAmount::from_whole(deal_size), // Also spent deal size - datacap_state.token.get_balance(*v.blockstore(), verified_client2.id().unwrap()).unwrap() + datacap_state + .token + .get_balance(&DynBlockstore::wrap(v.blockstore()), verified_client2.id().unwrap()) + .unwrap() ); assert_eq!( TokenAmount::zero(), // All burnt datacap_state .token - .get_balance(*v.blockstore(), VERIFIED_REGISTRY_ACTOR_ADDR.id().unwrap()) + .get_balance( + &DynBlockstore::wrap(v.blockstore()), + VERIFIED_REGISTRY_ACTOR_ADDR.id().unwrap() + ) .unwrap() ); assert_eq!( @@ -344,7 +372,7 @@ fn expired_allocations() { expired_allocations_test(&v); } -fn expired_allocations_test(v: &dyn VM) { +fn expired_allocations_test(v: &dyn VM) { 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]); @@ -399,12 +427,12 @@ fn expired_allocations_test(v: &dyn VM) { // Deal has expired and cleaned up. let market_state: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); - let proposals: DealArray = - DealArray::load(&market_state.proposals, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let proposals = DealArray::load(&market_state.proposals, &store).unwrap(); assert!(proposals.get(deal1).unwrap().is_none()); - let pending_deal_allocs: Map = make_map_with_root_and_bitwidth( + let pending_deal_allocs: Map<_, AllocationID> = make_map_with_root_and_bitwidth( &market_state.pending_deal_allocation_ids, - *v.blockstore(), + &store, HAMT_BIT_WIDTH, ) .unwrap(); @@ -413,14 +441,16 @@ fn expired_allocations_test(v: &dyn VM) { // Allocation still exists until explicit cleanup let alloc_id = 1; let verifreg_state: VerifregState = get_state(v, &VERIFIED_REGISTRY_ACTOR_ADDR).unwrap(); - let mut allocs = verifreg_state.load_allocs(*v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let mut allocs = verifreg_state.load_allocs(&store).unwrap(); assert!(allocs.get(verified_client.id().unwrap(), alloc_id).unwrap().is_some()); verifreg_remove_expired_allocations(v, &worker, &verified_client, vec![], deal_size); // Allocation is gone let verifreg_state: VerifregState = get_state(v, &VERIFIED_REGISTRY_ACTOR_ADDR).unwrap(); - let mut allocs = verifreg_state.load_allocs(*v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let mut allocs = verifreg_state.load_allocs(&store).unwrap(); assert!(allocs.get(verified_client.id().unwrap(), alloc_id).unwrap().is_none()); // Client has original datacap balance @@ -436,7 +466,7 @@ fn deal_passes_claim_fails() { deal_passes_claim_fails_test(&v); } -fn deal_passes_claim_fails_test(v: &dyn VM) { +fn deal_passes_claim_fails_test(v: &dyn VM) { 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]); @@ -540,7 +570,8 @@ fn deal_passes_claim_fails_test(v: &dyn VM) { // Verify deal state. let market_state: MarketState = get_state(v, &STORAGE_MARKET_ACTOR_ADDR).unwrap(); - let deal_states = DealMetaArray::load(&market_state.states, *v.blockstore()).unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let deal_states = DealMetaArray::load(&market_state.states, &store).unwrap(); // bad deal sector can't be confirmed for commit so bad deal must not be included let bad_deal_state = deal_states.get(bad_deal).unwrap(); assert_eq!(None, bad_deal_state); @@ -551,10 +582,12 @@ fn deal_passes_claim_fails_test(v: &dyn VM) { // Verify sector info let miner_state: MinerState = get_state(v, &miner_id).unwrap(); // bad deal sector can't be confirmed for commit because alloc can't be claimed - let sector_info_b = miner_state.get_sector(*v.blockstore(), sector_number_b).unwrap(); + let sector_info_b = + miner_state.get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number_b).unwrap(); assert_eq!(None, sector_info_b); // deal sector fails because confirm for commit is now all or nothing - let sector_info_a = miner_state.get_sector(*v.blockstore(), sector_number_a).unwrap(); + let sector_info_a = + miner_state.get_sector(&DynBlockstore::wrap(v.blockstore()), sector_number_a).unwrap(); assert_eq!(None, sector_info_a); // run check before last change and confirm that we hit the expected broken state error diff --git a/test_vm/tests/verifreg_remove_datacap_test.rs b/test_vm/tests/verifreg_remove_datacap_test.rs index 22ad4f629..c291801b6 100644 --- a/test_vm/tests/verifreg_remove_datacap_test.rs +++ b/test_vm/tests/verifreg_remove_datacap_test.rs @@ -1,4 +1,4 @@ -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_ipld_encoding::{to_vec, RawBytes}; use fvm_shared::bigint::bigint_ser::BigIntDe; use fvm_shared::bigint::{BigInt, Zero}; @@ -29,6 +29,7 @@ use test_vm::expects::Expect; use test_vm::trace::ExpectInvocation; use test_vm::util::{ apply_code, apply_ok, assert_invariants, create_accounts, get_state, verifreg_add_verifier, + DynBlockstore, }; use test_vm::{TestVM, TEST_VERIFREG_ROOT_ADDR, VM}; @@ -39,7 +40,7 @@ fn remove_datacap_simple_successful_path() { remove_datacap_simple_successful_path_test(&v); } -fn remove_datacap_simple_successful_path_test(v: &dyn VM) { +fn remove_datacap_simple_successful_path_test(v: &dyn VM) { let addrs = create_accounts(v, 4, &TokenAmount::from_whole(10_000)); let (verifier1, verifier2, verified_client) = (addrs[0], addrs[1], addrs[2]); @@ -89,12 +90,10 @@ fn remove_datacap_simple_successful_path_test(v: &dyn VM) { // state checks on the 2 verifiers and the client let v_st: VerifregState = get_state(v, &VERIFIED_REGISTRY_ACTOR_ADDR).unwrap(); - let verifiers = make_map_with_root_and_bitwidth::<_, BigIntDe>( - &v_st.verifiers, - *v.blockstore(), - HAMT_BIT_WIDTH, - ) - .unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + let verifiers = + make_map_with_root_and_bitwidth::<_, BigIntDe>(&v_st.verifiers, &store, HAMT_BIT_WIDTH) + .unwrap(); let BigIntDe(verifier1_data_cap) = verifiers.get(&verifier1_id_addr.to_bytes()).unwrap().unwrap(); @@ -105,12 +104,15 @@ fn remove_datacap_simple_successful_path_test(v: &dyn VM) { assert_eq!(verifier_allowance, *verifier2_data_cap); let token_st: DataCapState = get_state(v, &DATACAP_TOKEN_ACTOR_ADDR).unwrap(); - let balance = token_st.balance(*v.blockstore(), verified_client_id_addr.id().unwrap()).unwrap(); + let balance = token_st + .balance(&DynBlockstore::wrap(v.blockstore()), verified_client_id_addr.id().unwrap()) + .unwrap(); assert_eq!(balance, TokenAmount::from_whole(verifier_allowance.to_i64().unwrap())); + let store = DynBlockstore::wrap(v.blockstore()); let mut proposal_ids = make_map_with_root_and_bitwidth::<_, RemoveDataCapProposalID>( &v_st.remove_data_cap_proposal_ids, - *v.blockstore(), + &store, HAMT_BIT_WIDTH, ) .unwrap(); @@ -183,7 +185,9 @@ fn remove_datacap_simple_successful_path_test(v: &dyn VM) { // confirm client's allowance has fallen by half let token_st: DataCapState = get_state(v, &DATACAP_TOKEN_ACTOR_ADDR).unwrap(); - let balance = token_st.balance(*v.blockstore(), verified_client_id_addr.id().unwrap()).unwrap(); + let balance = token_st + .balance(&DynBlockstore::wrap(v.blockstore()), verified_client_id_addr.id().unwrap()) + .unwrap(); assert_eq!( balance, TokenAmount::from_whole(verifier_allowance.sub(&allowance_to_remove).to_i64().unwrap()) @@ -191,12 +195,10 @@ fn remove_datacap_simple_successful_path_test(v: &dyn VM) { let v_st: VerifregState = get_state(v, &VERIFIED_REGISTRY_ACTOR_ADDR).unwrap(); // confirm proposalIds has changed as expected - proposal_ids = make_map_with_root_and_bitwidth( - &v_st.remove_data_cap_proposal_ids, - *v.blockstore(), - HAMT_BIT_WIDTH, - ) - .unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + proposal_ids = + make_map_with_root_and_bitwidth(&v_st.remove_data_cap_proposal_ids, &store, HAMT_BIT_WIDTH) + .unwrap(); let verifier1_proposal_id: &RemoveDataCapProposalID = proposal_ids .get(&AddrPairKey::new(verifier1_id_addr, verified_client_id_addr).to_bytes()) @@ -271,17 +273,17 @@ fn remove_datacap_simple_successful_path_test(v: &dyn VM) { // confirm client has no balance let token_st: DataCapState = get_state(v, &DATACAP_TOKEN_ACTOR_ADDR).unwrap(); - let balance = token_st.balance(*v.blockstore(), verified_client_id_addr.id().unwrap()).unwrap(); + let balance = token_st + .balance(&DynBlockstore::wrap(v.blockstore()), verified_client_id_addr.id().unwrap()) + .unwrap(); assert_eq!(balance, TokenAmount::zero()); // confirm proposalIds has changed as expected let v_st: VerifregState = get_state(v, &VERIFIED_REGISTRY_ACTOR_ADDR).unwrap(); - proposal_ids = make_map_with_root_and_bitwidth( - &v_st.remove_data_cap_proposal_ids, - *v.blockstore(), - HAMT_BIT_WIDTH, - ) - .unwrap(); + let store = DynBlockstore::wrap(v.blockstore()); + proposal_ids = + make_map_with_root_and_bitwidth(&v_st.remove_data_cap_proposal_ids, &store, HAMT_BIT_WIDTH) + .unwrap(); let verifier1_proposal_id: &RemoveDataCapProposalID = proposal_ids .get(&AddrPairKey::new(verifier1_id_addr, verified_client_id_addr).to_bytes()) @@ -306,7 +308,7 @@ fn remove_datacap_fails_on_verifreg() { remove_datacap_fails_on_verifreg_test(&v); } -fn remove_datacap_fails_on_verifreg_test(v: &dyn VM) { +fn remove_datacap_fails_on_verifreg_test(v: &dyn VM) { let addrs = create_accounts(v, 2, &TokenAmount::from_whole(10_000)); let (verifier1, verifier2) = (addrs[0], addrs[1]); diff --git a/test_vm/tests/withdraw_balance_test.rs b/test_vm/tests/withdraw_balance_test.rs index 9bc483674..de7b0153c 100644 --- a/test_vm/tests/withdraw_balance_test.rs +++ b/test_vm/tests/withdraw_balance_test.rs @@ -1,5 +1,5 @@ use fil_actor_miner::{ChangeBeneficiaryParams, Method as MinerMethod, WithdrawBalanceParams}; -use fvm_ipld_blockstore::{Blockstore, MemoryBlockstore}; +use fvm_ipld_blockstore::MemoryBlockstore; use fvm_shared::bigint::Zero; use fvm_shared::econ::TokenAmount; use fvm_shared::error::ExitCode; @@ -16,7 +16,7 @@ fn withdraw_balance_success() { withdraw_balance_success_test(&v); } -fn withdraw_balance_success_test(v: &dyn VM) { +fn withdraw_balance_success_test(v: &dyn VM) { let addrs = create_accounts(v, 2, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, beneficiary) = (addrs[0], addrs[0], addrs[1]); @@ -59,10 +59,10 @@ fn withdraw_balance_success_test(v: &dyn VM) { fn withdraw_balance_fail() { let store = MemoryBlockstore::new(); let v = TestVM::::new_with_singletons(&store); - withdraw_balance_fail_test::(&v); + withdraw_balance_fail_test(&v); } -fn withdraw_balance_fail_test(v: &dyn VM) { +fn withdraw_balance_fail_test(v: &dyn VM) { let addrs = create_accounts(v, 3, &TokenAmount::from_whole(10_000)); let seal_proof = RegisteredSealProof::StackedDRG32GiBV1P1; let (owner, worker, beneficiary, addr) = (addrs[0], addrs[0], addrs[1], addrs[2]);