From 1e304d95ec4dc113fd5ee0baba6194fe7caf65cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= Date: Fri, 16 Apr 2021 07:06:45 -0700 Subject: [PATCH] Some clippy fixes .. while reading around --- blockchain/blocks/src/election_proof.rs | 5 +- blockchain/chain/src/store/chain_store.rs | 2 +- blockchain/chain_sync/src/sync.rs | 2 +- blockchain/chain_sync/src/sync/peer_test.rs | 8 +- blockchain/chain_sync/src/sync_worker.rs | 2 +- .../src/sync_worker/full_sync_test.rs | 2 +- .../src/sync_worker/validate_block_test.rs | 2 +- blockchain/message_pool/src/msgpool/mod.rs | 6 +- blockchain/state_manager/src/utils.rs | 39 +++++---- encoding/src/bytes.rs | 2 +- ipld/amt/src/node.rs | 1 + ipld/blockstore/src/buffered.rs | 10 +-- ipld/cid/src/lib.rs | 2 +- ipld/cid/tests/base_cid_tests.rs | 2 +- ipld/hamt/tests/hamt_tests.rs | 2 +- ipld/tests/cbor_test.rs | 10 +-- key_management/src/wallet.rs | 12 +-- node/db/tests/subtests/mod.rs | 16 ++-- .../src/chain_exchange/message.rs | 6 +- node/rpc/src/sync_api.rs | 8 +- utils/bitfield/benches/benchmarks/main.rs | 2 +- utils/bitfield/src/rleplus/reader.rs | 2 +- utils/bitfield/src/rleplus/writer.rs | 2 +- utils/commcid/tests/commcid_tests.rs | 4 +- utils/genesis/src/lib.rs | 3 +- utils/json_utils/src/lib.rs | 2 +- utils/test_utils/src/chain_structures.rs | 2 +- vm/actor/src/builtin/miner/mod.rs | 5 +- vm/actor/tests/alpha_beta_filter_test.rs | 16 ++-- vm/actor/tests/common/mod.rs | 33 ++++---- vm/actor/tests/cron_actor_test.rs | 12 +-- vm/actor/tests/init_actor_test.rs | 52 ++++++------ vm/actor/tests/paych_actor_test.rs | 82 +++++++++---------- vm/actor/tests/reward_actor_test.rs | 6 +- vm/address/src/lib.rs | 2 +- vm/address/src/payload.rs | 8 +- vm/address/tests/address_test.rs | 14 ++-- vm/interpreter/src/default_runtime.rs | 9 +- vm/interpreter/tests/transfer_test.rs | 26 +++--- vm/message/src/unsigned_message.rs | 13 +-- vm/src/actor_state.rs | 7 +- vm/state_tree/tests/state_tree_tests.rs | 36 ++++---- 42 files changed, 223 insertions(+), 254 deletions(-) diff --git a/blockchain/blocks/src/election_proof.rs b/blockchain/blocks/src/election_proof.rs index 551b118dd243..4bef8c3804f5 100644 --- a/blockchain/blocks/src/election_proof.rs +++ b/blockchain/blocks/src/election_proof.rs @@ -214,10 +214,7 @@ pub mod json { vrfproof, win_count, } = Deserialize::deserialize(deserializer)?; - Ok(ElectionProof { - vrfproof, - win_count, - }) + Ok(ElectionProof { win_count, vrfproof }) } pub mod opt { diff --git a/blockchain/chain/src/store/chain_store.rs b/blockchain/chain/src/store/chain_store.rs index 606390ea1de9..8c25c7c595b6 100644 --- a/blockchain/chain/src/store/chain_store.rs +++ b/blockchain/chain/src/store/chain_store.rs @@ -1080,7 +1080,7 @@ mod tests { let cs = ChainStore::new(Arc::new(db)); let gen_block = BlockHeader::builder() .epoch(1) - .weight((2 as u32).into()) + .weight(2_u32.into()) .messages(cid::new_from_cbor(&[], Identity)) .message_receipts(cid::new_from_cbor(&[], Identity)) .state_root(cid::new_from_cbor(&[], Identity)) diff --git a/blockchain/chain_sync/src/sync.rs b/blockchain/chain_sync/src/sync.rs index 14839509068f..c9377a202f1c 100644 --- a/blockchain/chain_sync/src/sync.rs +++ b/blockchain/chain_sync/src/sync.rs @@ -673,7 +673,7 @@ mod tests { Sender, Receiver, ) { - let chain_store = Arc::new(ChainStore::new(db.clone())); + let chain_store = Arc::new(ChainStore::new(db)); let test_provider = TestApi::default(); let (tx, _rx) = bounded(10); let mpool = task::block_on(MessagePool::new( diff --git a/blockchain/chain_sync/src/sync/peer_test.rs b/blockchain/chain_sync/src/sync/peer_test.rs index 87122fac915a..3a898bfe9ca7 100644 --- a/blockchain/chain_sync/src/sync/peer_test.rs +++ b/blockchain/chain_sync/src/sync/peer_test.rs @@ -19,7 +19,7 @@ use std::time::Duration; fn peer_manager_update() { let db = Arc::new(MemoryDB::default()); - let chain_store = Arc::new(ChainStore::new(db.clone())); + let chain_store = Arc::new(ChainStore::new(db)); let (tx, _rx) = bounded(10); let mpool = task::block_on(MessagePool::new( TestApi::default(), @@ -61,7 +61,7 @@ fn peer_manager_update() { ) .unwrap(); - let peer_manager = Arc::clone(&cs.network.peer_manager.clone()); + let peer_manager = Arc::clone(&cs.network.peer_manager); let (worker_tx, worker_rx) = bounded(10); task::spawn(async { @@ -69,9 +69,9 @@ fn peer_manager_update() { }); let source = PeerId::random(); - let source_clone = source.clone(); + let source_clone = source; - let gen_cloned = genesis_ts.clone(); + let gen_cloned = genesis_ts; task::block_on(async { event_sender .send(NetworkEvent::HelloRequest { diff --git a/blockchain/chain_sync/src/sync_worker.rs b/blockchain/chain_sync/src/sync_worker.rs index 6a6cf473122a..65588810409e 100644 --- a/blockchain/chain_sync/src/sync_worker.rs +++ b/blockchain/chain_sync/src/sync_worker.rs @@ -1079,7 +1079,7 @@ mod tests { task::block_on(async move { sw.network .peer_manager() - .update_peer_head(source.clone(), head.clone()) + .update_peer_head(source, head.clone()) .await; assert_eq!(sw.network.peer_manager().len().await, 1); // make chain_exchange request diff --git a/blockchain/chain_sync/src/sync_worker/full_sync_test.rs b/blockchain/chain_sync/src/sync_worker/full_sync_test.rs index b8a5dcc1aee6..c430209525d9 100644 --- a/blockchain/chain_sync/src/sync_worker/full_sync_test.rs +++ b/blockchain/chain_sync/src/sync_worker/full_sync_test.rs @@ -64,7 +64,7 @@ async fn space_race_full_sync() { let network = SyncNetworkContext::new(network_send, Arc::new(peer_manager), db); let provider_db = Arc::new(MemoryDB::default()); - let cids: Vec = load_car(provider_db.as_ref(), EXPORT_SR_40.as_ref()) + let cids: Vec = load_car(provider_db.as_ref(), EXPORT_SR_40) .await .unwrap(); let prov_cs = ChainStore::new(provider_db); diff --git a/blockchain/chain_sync/src/sync_worker/validate_block_test.rs b/blockchain/chain_sync/src/sync_worker/validate_block_test.rs index d235d3b5c0a9..5844fbb80135 100644 --- a/blockchain/chain_sync/src/sync_worker/validate_block_test.rs +++ b/blockchain/chain_sync/src/sync_worker/validate_block_test.rs @@ -21,7 +21,7 @@ async fn validate_specific_block() { let db = Arc::new(MemoryDB::default()); - let cids = load_car(db.as_ref(), EXPORT_SR_40.as_ref()).await.unwrap(); + let cids = load_car(db.as_ref(), EXPORT_SR_40).await.unwrap(); let chain_store = Arc::new(ChainStore::new(db.clone())); let state_manager = Arc::new(StateManager::new(chain_store.clone())); diff --git a/blockchain/message_pool/src/msgpool/mod.rs b/blockchain/message_pool/src/msgpool/mod.rs index b6e9ecfaa18c..626136ced93b 100644 --- a/blockchain/message_pool/src/msgpool/mod.rs +++ b/blockchain/message_pool/src/msgpool/mod.rs @@ -458,8 +458,8 @@ pub mod tests { gas_price: u64, ) -> SignedMessage { let umsg: UnsignedMessage = UnsignedMessage::builder() - .to(to.clone()) - .from(from.clone()) + .to(*to) + .from(*from) .sequence(sequence) .gas_limit(gas_limit) .gas_fee_cap((gas_price + 100).into()) @@ -860,7 +860,7 @@ pub mod tests { let mut smsg_vec = Vec::new(); tma.write() .await - .set_state_balance_raw(&a1, BigInt::from(1_000_000_000_000_000_000 as u64)); + .set_state_balance_raw(&a1, BigInt::from(1_000_000_000_000_000_000_u64)); for i in 0..10 { let msg = if i != 5 { create_smsg(&a2, &a1, wallet.borrow_mut(), i, gas_limit, 1 + i) diff --git a/blockchain/state_manager/src/utils.rs b/blockchain/state_manager/src/utils.rs index ed556d787693..b06079865d00 100644 --- a/blockchain/state_manager/src/utils.rs +++ b/blockchain/state_manager/src/utils.rs @@ -43,31 +43,30 @@ where .ok_or_else(|| Error::State("Power actor address could not be resolved".to_string()))?; let mas = miner::State::load(self.blockstore(), &actor)?; - let proving_sectors = if nv < NetworkVersion::V7 { + let proving_sectors = { let mut proving_sectors = BitField::new(); - mas.for_each_deadline(store, |_, deadline| { - let mut fault_sectors = BitField::new(); - deadline.for_each(store, |_, partition: miner::Partition| { - proving_sectors |= &partition.all_sectors(); - fault_sectors |= &partition.faulty_sectors(); - Ok(()) - })?; - proving_sectors -= &fault_sectors; - Ok(()) - })?; + if nv < NetworkVersion::V7 { + mas.for_each_deadline(store, |_, deadline| { + let mut fault_sectors = BitField::new(); + deadline.for_each(store, |_, partition: miner::Partition| { + proving_sectors |= &partition.all_sectors(); + fault_sectors |= &partition.faulty_sectors(); + Ok(()) + })?; - proving_sectors - } else { - let mut proving_sectors = BitField::new(); - mas.for_each_deadline(store, |_, deadline| { - deadline.for_each(store, |_, partition: miner::Partition| { - proving_sectors |= &partition.active_sectors(); + proving_sectors -= &fault_sectors; Ok(()) })?; - Ok(()) - })?; - + } else { + mas.for_each_deadline(store, |_, deadline| { + deadline.for_each(store, |_, partition: miner::Partition| { + proving_sectors |= &partition.active_sectors(); + Ok(()) + })?; + Ok(()) + })?; + } proving_sectors }; diff --git a/encoding/src/bytes.rs b/encoding/src/bytes.rs index 3dcc19be9386..9da3b08a83b9 100644 --- a/encoding/src/bytes.rs +++ b/encoding/src/bytes.rs @@ -48,7 +48,7 @@ mod tests { #[test] fn array_symmetric_serialization() { - let vec: Vec = (0..32).map(|x| x).collect::>(); + let vec: Vec = (0..32).collect::>(); let slice_bz = to_vec(&BytesSer(&vec)).unwrap(); let Byte32De(arr) = from_slice(&slice_bz).unwrap(); // Check decoded array against slice diff --git a/ipld/amt/src/node.rs b/ipld/amt/src/node.rs index 0ea64cb9d285..9c88691fbaa0 100644 --- a/ipld/amt/src/node.rs +++ b/ipld/amt/src/node.rs @@ -187,6 +187,7 @@ where /// Flushes cache for node, replacing any cached values with a Cid variant pub(super) fn flush(&mut self, bs: &DB) -> Result<(), Error> { if let Node::Link { links } = self { + #[allow(clippy::manual_flatten)] for link in links.iter_mut() { // links should only be flushed if the bitmap is set. if let Some(Link::Dirty(n)) = link { diff --git a/ipld/blockstore/src/buffered.rs b/ipld/blockstore/src/buffered.rs index 4dbe73a88969..184de24e15c8 100644 --- a/ipld/blockstore/src/buffered.rs +++ b/ipld/blockstore/src/buffered.rs @@ -299,16 +299,16 @@ mod tests { ) .unwrap(); let map = ipld!({ - "array": Link(arr_cid.clone()), - "sealed": Link(sealed_comm_cid.clone()), - "unsealed": Link(unsealed_comm_cid.clone()), - "identity": Link(identity_cid.clone()), + "array": Link(arr_cid), + "sealed": Link(sealed_comm_cid), + "unsealed": Link(unsealed_comm_cid), + "identity": Link(identity_cid), "value": str_val, }); let map_cid = buf_store.put(&map, Code::Blake2b256).unwrap(); let root_cid = buf_store - .put(&(map_cid.clone(), 1u8), Code::Blake2b256) + .put(&(map_cid, 1u8), Code::Blake2b256) .unwrap(); // Make sure a block not connected to the root does not get written diff --git a/ipld/cid/src/lib.rs b/ipld/cid/src/lib.rs index 6773b2be2b82..407f3b767ad4 100644 --- a/ipld/cid/src/lib.rs +++ b/ipld/cid/src/lib.rs @@ -90,7 +90,7 @@ impl Cid { } /// Returns the encoded bytes of the `Cid`. - pub fn to_bytes(&self) -> Vec { + pub fn to_bytes(self) -> Vec { self.0.to_bytes() } } diff --git a/ipld/cid/tests/base_cid_tests.rs b/ipld/cid/tests/base_cid_tests.rs index b982e970ef44..63742ac01118 100644 --- a/ipld/cid/tests/base_cid_tests.rs +++ b/ipld/cid/tests/base_cid_tests.rs @@ -100,7 +100,7 @@ fn test_hash() { }; let mut map = HashMap::new(); let cid = forest_cid::new_from_prefix(&prefix, &data).unwrap(); - map.insert(cid.clone(), data.clone()); + map.insert(cid, data.clone()); assert_eq!(&data, map.get(&cid).unwrap()); } diff --git a/ipld/hamt/tests/hamt_tests.rs b/ipld/hamt/tests/hamt_tests.rs index 234913d84a3c..155f54f1c90c 100644 --- a/ipld/hamt/tests/hamt_tests.rs +++ b/ipld/hamt/tests/hamt_tests.rs @@ -453,7 +453,7 @@ fn clean_child_ordering() { let mut h: Hamt<_, _> = Hamt::new_with_bit_width(&store, 5); for i in 100..195 { - h.set(make_key(i), dummy_value.clone()).unwrap(); + h.set(make_key(i), dummy_value).unwrap(); } let root = h.flush().unwrap(); diff --git a/ipld/tests/cbor_test.rs b/ipld/tests/cbor_test.rs index 1fe41d6e3775..de680de2be97 100644 --- a/ipld/tests/cbor_test.rs +++ b/ipld/tests/cbor_test.rs @@ -21,7 +21,7 @@ fn encode_new_type() { let name = "Test".to_string(); let t_struct = TestStruct { name: name.clone(), - details: details.clone(), + details, }; let struct_encoded = to_vec(&t_struct).unwrap(); @@ -43,14 +43,14 @@ fn cid_conversions_ipld() { let cid = cid::new_from_cbor(&[1, 2, 3], Blake2b256); let m_s = TestStruct { name: "s".to_owned(), - details: cid.clone(), + details: cid, }; assert_eq!( to_ipld(&m_s).unwrap(), - ipld!({"name": "s", "details": Link(cid.clone()) }) + ipld!({"name": "s", "details": Link(cid) }) ); let serialized = to_vec(&cid).unwrap(); - let ipld = ipld!(Link(cid.clone())); + let ipld = ipld!(Link(cid)); let ipld2 = to_ipld(&cid).unwrap(); assert_eq!(ipld, ipld2); assert_eq!(to_vec(&ipld).unwrap(), serialized); @@ -58,7 +58,7 @@ fn cid_conversions_ipld() { // Test with identity hash (different length prefix for cbor) let cid = cid::new_from_cbor(&[1, 2], Identity); - let ipld = ipld!(Link(cid.clone())); + let ipld = ipld!(Link(cid)); let ipld2 = to_ipld(&cid).unwrap(); assert_eq!(ipld, ipld2); } diff --git a/key_management/src/wallet.rs b/key_management/src/wallet.rs index 6c76e5b5c4d3..85bc0f01bf25 100644 --- a/key_management/src/wallet.rs +++ b/key_management/src/wallet.rs @@ -254,7 +254,7 @@ mod tests { fn contains_key() { let key_vec = construct_priv_keys(); let found_key = key_vec[0].clone(); - let addr = key_vec[0].address.clone(); + let addr = key_vec[0].address; let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), key_vec); @@ -281,7 +281,7 @@ mod tests { fn sign() { let key_vec = construct_priv_keys(); let priv_key_bytes = key_vec[2].key_info.private_key().clone(); - let addr = key_vec[2].address.clone(); + let addr = key_vec[2].address; let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), key_vec); let msg = [0u8; 64]; @@ -306,7 +306,7 @@ mod tests { let key_info = wallet.export(&key.address).unwrap(); // test to see if export returns the correct key_info - assert_eq!(key_info, key.key_info.clone()); + assert_eq!(key_info, key.key_info); let new_priv_key = generate(SignatureType::Secp256k1).unwrap(); let pub_key = @@ -391,7 +391,7 @@ mod tests { wallet.keystore.put(test_addr_string, key_info).unwrap(); // check to make sure that the set_default function completed without error - assert!(wallet.set_default(test_addr.clone()).is_ok()); + assert!(wallet.set_default(test_addr).is_ok()); // check to make sure that the test_addr is actually the default addr for the wallet assert_eq!(wallet.get_default().unwrap(), test_addr); @@ -402,7 +402,7 @@ mod tests { let secp_priv_key = generate(SignatureType::Secp256k1).unwrap(); let secp_key_info = KeyInfo::new(SignatureType::Secp256k1, secp_priv_key); let secp_key = Key::try_from(secp_key_info).unwrap(); - let addr = secp_key.address.clone(); + let addr = secp_key.address; let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), vec![secp_key]); let msg = [0u8; 64]; @@ -420,7 +420,7 @@ mod tests { let bls_priv_key = generate(SignatureType::BLS).unwrap(); let bls_key_info = KeyInfo::new(SignatureType::BLS, bls_priv_key); let bls_key = Key::try_from(bls_key_info).unwrap(); - let addr = bls_key.address.clone(); + let addr = bls_key.address; let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), vec![bls_key]); let msg = [0u8; 64]; diff --git a/node/db/tests/subtests/mod.rs b/node/db/tests/subtests/mod.rs index 2fa9756faf63..38c3458ba9e8 100644 --- a/node/db/tests/subtests/mod.rs +++ b/node/db/tests/subtests/mod.rs @@ -18,7 +18,7 @@ where { let key = [0]; let value = [1]; - db.write(key.clone(), value.clone()).unwrap(); + db.write(key, value).unwrap(); let res = db.read(key).unwrap().unwrap(); assert_eq!(value.as_ref(), res.as_slice()); } @@ -29,7 +29,7 @@ where { let key = [0]; let value = [1]; - db.write(key.clone(), value.clone()).unwrap(); + db.write(key, value).unwrap(); let res = db.exists(key).unwrap(); assert_eq!(res, true); } @@ -49,11 +49,11 @@ where { let key = [0]; let value = [1]; - db.write(key.clone(), value.clone()).unwrap(); - let res = db.exists(key.clone()).unwrap(); + db.write(key, value).unwrap(); + let res = db.exists(key).unwrap(); assert_eq!(res, true); - db.delete(key.clone()).unwrap(); - let res = db.exists(key.clone()).unwrap(); + db.delete(key).unwrap(); + let res = db.exists(key).unwrap(); assert_eq!(res, false); } @@ -64,7 +64,7 @@ where let values = [([0], [0]), ([1], [1]), ([2], [2])]; db.bulk_write(&values).unwrap(); for (k, _) in values.iter() { - let res = db.exists(k.clone()).unwrap(); + let res = db.exists(*k).unwrap(); assert_eq!(res, true); } } @@ -96,7 +96,7 @@ where db.bulk_write(&kvs).unwrap(); db.bulk_delete(&keys).unwrap(); for k in keys.iter() { - let res = db.exists(k.clone()).unwrap(); + let res = db.exists(*k).unwrap(); assert_eq!(res, false); } } diff --git a/node/forest_libp2p/src/chain_exchange/message.rs b/node/forest_libp2p/src/chain_exchange/message.rs index 2c71afa7820c..bd71c034bd71 100644 --- a/node/forest_libp2p/src/chain_exchange/message.rs +++ b/node/forest_libp2p/src/chain_exchange/message.rs @@ -234,11 +234,7 @@ fn fts_from_bundle_parts( let bls_messages = values_from_indexes(&bls_msg_includes[i], &bls_msgs)?; let secp_messages = values_from_indexes(&secp_msg_includes[i], &secp_msgs)?; - Ok(Block { - header, - secp_messages, - bls_messages, - }) + Ok(Block { header, bls_messages, secp_messages }) }) .collect::>()?; diff --git a/node/rpc/src/sync_api.rs b/node/rpc/src/sync_api.rs index ff6ce57e9ecc..1e526a65d7fa 100644 --- a/node/rpc/src/sync_api.rs +++ b/node/rpc/src/sync_api.rs @@ -203,7 +203,7 @@ mod tests { .unwrap(); match sync_check_bad(Data(state.clone()), Params((cid.clone(),))).await { Ok(reason) => assert_eq!(reason, ""), - Err(e) => panic!(e), + Err(e) => std::panic::panic_any(e), } // Mark that block as bad manually and check again to verify @@ -212,7 +212,7 @@ mod tests { .is_ok()); match sync_check_bad(Data(state), Params((cid,))).await { Ok(reason) => assert_eq!(reason, "Marked bad manually through RPC API"), - Err(e) => panic!(e), + Err(e) => std::panic::panic_any(e), } } @@ -224,7 +224,7 @@ mod tests { match sync_state(Data(state.clone())).await { Ok(ret) => assert_eq!(ret.active_syncs, clone_state(st_copy.as_ref()).await), - Err(e) => panic!(e), + Err(e) => std::panic::panic_any(e), } // update cloned state @@ -239,7 +239,7 @@ mod tests { assert_ne!(ret.active_syncs, vec![]); assert_eq!(ret.active_syncs, clone_state(st_copy.as_ref()).await); } - Err(e) => panic!(e), + Err(e) => std::panic::panic_any(e), } } } diff --git a/utils/bitfield/benches/benchmarks/main.rs b/utils/bitfield/benches/benchmarks/main.rs index 3eecd2f71f06..2e1ebbed7c97 100644 --- a/utils/bitfield/benches/benchmarks/main.rs +++ b/utils/bitfield/benches/benchmarks/main.rs @@ -21,7 +21,7 @@ fn bits(c: &mut Criterion) { } fn new(c: &mut Criterion) { - c.bench_function("new", |b| b.iter(|| example1())); + c.bench_function("new", |b| b.iter(example1)); } fn decode_encode(c: &mut Criterion) { diff --git a/utils/bitfield/src/rleplus/reader.rs b/utils/bitfield/src/rleplus/reader.rs index 65a321c58dfe..a6e3bc4af0c9 100644 --- a/utils/bitfield/src/rleplus/reader.rs +++ b/utils/bitfield/src/rleplus/reader.rs @@ -146,7 +146,7 @@ mod tests { #[test] fn read_len() { - let bytes = &[0b0_001010_1, 0b110_10111, 0b01100_111, 0b00110010]; + let bytes = &[0b0001_0101, 0b1101_0111, 0b0110_0111, 0b00110010]; let mut reader = BitReader::new(bytes); assert_eq!(reader.read_len().unwrap(), Some(1)); // prefix: 1 diff --git a/utils/bitfield/src/rleplus/writer.rs b/utils/bitfield/src/rleplus/writer.rs index fa8193262eb2..38ec176b47e3 100644 --- a/utils/bitfield/src/rleplus/writer.rs +++ b/utils/bitfield/src/rleplus/writer.rs @@ -131,7 +131,7 @@ mod tests { writer.write_len(147); // prefix: 00, value: 11001001 10000000 assert_eq!( - writer.clone().finish(), + writer.finish(), &[ 0b0001_0101, 0b1101_0111, diff --git a/utils/commcid/tests/commcid_tests.rs b/utils/commcid/tests/commcid_tests.rs index 389c7b3ea61f..eb16d5274a79 100644 --- a/utils/commcid/tests/commcid_tests.rs +++ b/utils/commcid/tests/commcid_tests.rs @@ -33,7 +33,7 @@ fn cid_to_comm_d() { // Correct hash format let mh = cid::Multihash::wrap(cid::SHA2_256_TRUNC254_PADDED, &comm).unwrap(); - let c = Cid::new_v1(cid::FIL_COMMITMENT_UNSEALED, mh.clone()); + let c = Cid::new_v1(cid::FIL_COMMITMENT_UNSEALED, mh); let decoded = cid_to_data_commitment_v1(&c).unwrap(); assert_eq!(decoded, comm); @@ -64,7 +64,7 @@ fn cid_to_comm_r() { // Correct hash format let mh = cid::Multihash::wrap(cid::POSEIDON_BLS12_381_A1_FC1, &comm).unwrap(); - let c = Cid::new_v1(cid::FIL_COMMITMENT_SEALED, mh.clone()); + let c = Cid::new_v1(cid::FIL_COMMITMENT_SEALED, mh); let decoded = cid_to_replica_commitment_v1(&c).unwrap(); assert_eq!(decoded, comm); diff --git a/utils/genesis/src/lib.rs b/utils/genesis/src/lib.rs index 36a6692c469b..87c996838bfe 100644 --- a/utils/genesis/src/lib.rs +++ b/utils/genesis/src/lib.rs @@ -78,15 +78,14 @@ where .unwrap_or_default() { debug!("Genesis from config matches Genesis from store"); - Ok(genesis_block) } else { debug!("Initialize ChainSyncer with new genesis from config"); chain_store.set_genesis(&genesis_block)?; async_std::task::block_on( chain_store.set_heaviest_tipset(Arc::new(Tipset::new(vec![genesis_block.clone()])?)), )?; - Ok(genesis_block) } + Ok(genesis_block) } /// Import a chain from a CAR file. If the snapshot boolean is set, it will not verify the chain diff --git a/utils/json_utils/src/lib.rs b/utils/json_utils/src/lib.rs index 8c7d2e523d4c..8934b879f640 100644 --- a/utils/json_utils/src/lib.rs +++ b/utils/json_utils/src/lib.rs @@ -167,7 +167,7 @@ mod tests { struct BasicJson { #[serde(with = "go_vec_visitor")] ints: Vec, - }; + } let null_json = r#"null"#; let BasicJson { ints } = from_str(null_json).unwrap(); diff --git a/utils/test_utils/src/chain_structures.rs b/utils/test_utils/src/chain_structures.rs index 3c0c0ad72e29..047ab5706c98 100644 --- a/utils/test_utils/src/chain_structures.rs +++ b/utils/test_utils/src/chain_structures.rs @@ -150,7 +150,7 @@ pub fn construct_messages() -> (UnsignedMessage, SignedMessage) { pub fn construct_tipset_bundle(epoch: i64, weight: u64) -> TipsetBundle { let headers = construct_headers(epoch, weight); let (bls, secp) = construct_messages(); - let includes: Vec> = (0..headers.len()).map(|_| vec![]).collect(); + let includes: Vec> = (0..headers.len()).map(|_| Vec::new()).collect(); TipsetBundle { blocks: headers, diff --git a/vm/actor/src/builtin/miner/mod.rs b/vm/actor/src/builtin/miner/mod.rs index a7dc80b039d7..c95f973c859d 100644 --- a/vm/actor/src/builtin/miner/mod.rs +++ b/vm/actor/src/builtin/miner/mod.rs @@ -3583,10 +3583,7 @@ where let ret = rt.send( *STORAGE_MARKET_ACTOR_ADDR, MarketMethod::ComputeDataCommitment as u64, - Serialized::serialize(ComputeDataCommitmentParamsRef { - sector_type, - deal_ids, - })?, + Serialized::serialize(ComputeDataCommitmentParamsRef { deal_ids, sector_type })?, TokenAmount::zero(), )?; let unsealed_cid: Cid = ret.deserialize()?; diff --git a/vm/actor/tests/alpha_beta_filter_test.rs b/vm/actor/tests/alpha_beta_filter_test.rs index b07ec244f7fd..239fc9b56f44 100644 --- a/vm/actor/tests/alpha_beta_filter_test.rs +++ b/vm/actor/tests/alpha_beta_filter_test.rs @@ -23,7 +23,7 @@ fn per_million_error(val_1: &BigInt, val_2: &BigInt) -> BigInt { let diff_per_million = (ratio * million).abs(); - diff_per_million >> 2 * PRECISION + diff_per_million >> (2 * PRECISION) } fn iterative_cum_sum_of_ratio( @@ -135,7 +135,7 @@ fn constant_estimate() { // note: this is a bit sensative to input, lots of numbers approach from below // (...99999) and so truncating division takes us off by one let product = csr_frac * (BigInt::from(10_000) << PRECISION); // Q.256 - assert_eq!(BigInt::from(5000), product >> 2 * PRECISION); + assert_eq!(BigInt::from(5000), product >> (2 * PRECISION)); } #[test] @@ -171,7 +171,7 @@ fn values_in_range() { let four_fil_per_second = BigInt::from(100); let slow_money = testing_estimate(tens_of_fil.clone(), one_fil_per_sec); - let fast_money = testing_estimate(tens_of_fil.clone(), four_fil_per_second); + let fast_money = testing_estimate(tens_of_fil, four_fil_per_second); let tens_of_ei_bs = StoragePower::from(10_i128.pow(19)); let thousands_of_ei_bs = StoragePower::from(2 * 10_i128.pow(22)); @@ -188,18 +188,18 @@ fn values_in_range() { let test_cases: Vec<(StoragePower, BigInt)> = vec![ (tens_of_ei_bs.clone(), one_byte_per_epoch_velocity.clone()), (tens_of_ei_bs.clone(), ten_pi_bs_per_day_velocity.clone()), - (tens_of_ei_bs.clone(), one_ei_bs_per_day_velocity.clone()), + (tens_of_ei_bs, one_ei_bs_per_day_velocity.clone()), ( thousands_of_ei_bs.clone(), - one_byte_per_epoch_velocity.clone(), + one_byte_per_epoch_velocity, ), ( thousands_of_ei_bs.clone(), - ten_pi_bs_per_day_velocity.clone(), + ten_pi_bs_per_day_velocity, ), ( - thousands_of_ei_bs.clone(), - one_ei_bs_per_day_velocity.clone(), + thousands_of_ei_bs, + one_ei_bs_per_day_velocity, ), ]; diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 2d563611cc5e..3bc0b601c75e 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -173,7 +173,7 @@ impl MockRuntime { #[allow(dead_code)] pub fn expect_validate_caller_addr(&mut self, addr: Vec
) { - assert!(addr.len() > 0, "addrs must be non-empty"); + assert!(!addr.is_empty(), "addrs must be non-empty"); self.expect_validate_caller_addr = Some(addr); } @@ -201,8 +201,8 @@ impl MockRuntime { block_header_1: h1, block_header_2: h2, block_header_extra: extra, - fault: fault, - exit_code: exit_code, + fault, + exit_code, }); } @@ -213,7 +213,7 @@ impl MockRuntime { #[allow(dead_code)] pub fn expect_validate_caller_type(&mut self, types: Vec) { - assert!(types.len() > 0, "addrs must be non-empty"); + assert!(!types.is_empty(), "addrs must be non-empty"); self.expect_validate_caller_type = Some(types); } @@ -234,7 +234,7 @@ impl MockRuntime { params: &Serialized, ) -> Result { self.in_call = true; - let prev_state = self.state.clone(); + let prev_state = self.state; let res = forest_actor::invoke_code(to_code, self, method_num, params) .unwrap_or_else(|| Err(actor_error!(SysErrForbidden, "invalid method id"))); @@ -242,7 +242,7 @@ impl MockRuntime { self.state = prev_state; } self.in_call = false; - return res; + res } pub fn verify(&mut self) { assert!( @@ -345,7 +345,7 @@ impl MockRuntime { #[allow(dead_code)] pub fn set_caller(&mut self, code_id: Cid, address: Address) { self.caller = address; - self.caller_type = code_id.clone(); + self.caller_type = code_id; self.actor_code_cids.insert(address, code_id); } @@ -405,7 +405,7 @@ impl Runtime for MockRuntime { let addrs: Vec
= addresses.into_iter().cloned().collect(); - self.check_argument(addrs.len() > 0, "addrs must be non-empty".to_owned())?; + self.check_argument(!addrs.is_empty(), "addrs must be non-empty".to_owned())?; assert!( self.expect_validate_caller_addr.is_some(), @@ -437,7 +437,7 @@ impl Runtime for MockRuntime { self.require_in_call(); let types: Vec = types.into_iter().cloned().collect(); - self.check_argument(types.len() > 0, "types must be non-empty".to_owned())?; + self.check_argument(!types.is_empty(), "types must be non-empty".to_owned())?; assert!( self.expect_validate_caller_type.is_some(), @@ -473,7 +473,7 @@ impl Runtime for MockRuntime { fn resolve_address(&self, address: &Address) -> Result, ActorError> { self.require_in_call(); if address.protocol() == address::Protocol::ID { - return Ok(Some(address.clone())); + return Ok(Some(*address)); } Ok(self.id_addresses.get(&address).cloned()) @@ -504,7 +504,7 @@ impl Runtime for MockRuntime { } fn create(&mut self, obj: &C) -> Result<(), ActorError> { - if self.state.is_some() == true { + if self.state.is_some() { return Err(actor_error!(SysErrIllegalActor; "state already constructed")); } self.state = Some(self.store.put(obj, Blake2b256).unwrap()); @@ -573,22 +573,21 @@ impl Runtime for MockRuntime { self.balance -= value; match expected_msg.exit_code { - ExitCode::Ok => return Ok(expected_msg.send_return), + ExitCode::Ok => Ok(expected_msg.send_return), x => { - return Err(ActorError::new(x, "Expected message Fail".to_string())); + Err(ActorError::new(x, "Expected message Fail".to_string())) } } } fn new_actor_address(&mut self) -> Result { self.require_in_call(); - let ret = self + let ret = *self .new_actor_addr .as_ref() - .expect("unexpected call to new actor address") - .clone(); + .expect("unexpected call to new actor address"); self.new_actor_addr = None; - return Ok(ret); + Ok(ret) } fn create_actor(&mut self, code_id: Cid, address: &Address) -> Result<(), ActorError> { diff --git a/vm/actor/tests/cron_actor_test.rs b/vm/actor/tests/cron_actor_test.rs index e79111445130..733196be8213 100644 --- a/vm/actor/tests/cron_actor_test.rs +++ b/vm/actor/tests/cron_actor_test.rs @@ -13,8 +13,8 @@ use vm::{ExitCode, Serialized}; fn construct_runtime() -> MockRuntime { MockRuntime { receiver: Address::new_id(100), - caller: SYSTEM_ACTOR_ADDR.clone(), - caller_type: SYSTEM_ACTOR_CODE_ID.clone(), + caller: *SYSTEM_ACTOR_ADDR, + caller_type: *SYSTEM_ACTOR_CODE_ID, ..Default::default() } } @@ -101,7 +101,7 @@ fn epoch_tick_with_entries() { // ExitCodes dont matter here rt.expect_send( - entry1.receiver.clone(), + entry1.receiver, entry1.method_num, Serialized::default(), 0u8.into(), @@ -109,7 +109,7 @@ fn epoch_tick_with_entries() { ExitCode::Ok, ); rt.expect_send( - entry2.receiver.clone(), + entry2.receiver, entry2.method_num, Serialized::default(), 0u8.into(), @@ -117,7 +117,7 @@ fn epoch_tick_with_entries() { ExitCode::ErrIllegalArgument, ); rt.expect_send( - entry3.receiver.clone(), + entry3.receiver, entry3.method_num, Serialized::default(), 0u8.into(), @@ -125,7 +125,7 @@ fn epoch_tick_with_entries() { ExitCode::Ok, ); rt.expect_send( - entry4.receiver.clone(), + entry4.receiver, entry4.method_num, Serialized::default(), 0u8.into(), diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 39a58fa15f0b..b0dc235fed50 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -20,7 +20,7 @@ fn construct_runtime() -> MockRuntime { MockRuntime { receiver: Address::new_id(1000), caller: *SYSTEM_ACTOR_ADDR, - caller_type: SYSTEM_ACTOR_CODE_ID.clone(), + caller_type: *SYSTEM_ACTOR_CODE_ID, ..Default::default() } } @@ -32,9 +32,9 @@ fn abort_cant_call_exec() { construct_and_verify(&mut rt); let anne = Address::new_id(1001); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, anne); - let err = exec_and_verify(&mut rt, POWER_ACTOR_CODE_ID.clone(), &"") + let err = exec_and_verify(&mut rt, *POWER_ACTOR_CODE_ID, &"") .expect_err("Exec should have failed"); assert_eq!(err.exit_code(), ExitCode::ErrForbidden); } @@ -45,7 +45,7 @@ fn create_2_payment_channels() { construct_and_verify(&mut rt); let anne = Address::new_id(1001); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, anne); for n in 0..2 { let pay_channel_string = format!("paych_{}", n); @@ -58,7 +58,7 @@ fn create_2_payment_channels() { rt.new_actor_addr = Some(Address::new_actor(paych)); let expected_id_addr = Address::new_id(100 + n); - rt.expect_create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); + rt.expect_create_actor(*PAYCH_ACTOR_CODE_ID, expected_id_addr); let fake_params = ConstructorParams { network_name: String::from("fake_param"), @@ -68,7 +68,7 @@ fn create_2_payment_channels() { let balance = TokenAmount::from(100u8); rt.expect_send( - expected_id_addr.clone(), + expected_id_addr, METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), balance, @@ -76,7 +76,7 @@ fn create_2_payment_channels() { ExitCode::Ok, ); - let exec_ret = exec_and_verify(&mut rt, PAYCH_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret = exec_and_verify(&mut rt, *PAYCH_ACTOR_CODE_ID, &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!( unique_address, exec_ret.robust_address, @@ -104,22 +104,22 @@ fn create_storage_miner() { // only the storage power actor can create a miner rt.set_caller( - POWER_ACTOR_CODE_ID.clone(), - STORAGE_POWER_ACTOR_ADDR.clone(), + *POWER_ACTOR_CODE_ID, + *STORAGE_POWER_ACTOR_ADDR, ); let unique_address = Address::new_actor(b"miner"); - rt.new_actor_addr = Some(unique_address.clone()); + rt.new_actor_addr = Some(unique_address); let expected_id_addr = Address::new_id(100); - rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); + rt.expect_create_actor(*MINER_ACTOR_CODE_ID, expected_id_addr); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; rt.expect_send( - expected_id_addr.clone(), + expected_id_addr, METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), @@ -127,7 +127,7 @@ fn create_storage_miner() { ExitCode::Ok, ); - let exec_ret = exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret = exec_and_verify(&mut rt, *MINER_ACTOR_CODE_ID, &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!(unique_address, exec_ret.robust_address); @@ -158,22 +158,22 @@ fn create_multisig_actor() { // Actor creating multisig actor let some_acc_actor = Address::new_id(1234); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), some_acc_actor); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, some_acc_actor); // Assign addresses let unique_address = Address::new_actor(b"multisig"); - rt.new_actor_addr = Some(unique_address.clone()); + rt.new_actor_addr = Some(unique_address); // Next id let expected_id_addr = Address::new_id(100); - rt.expect_create_actor(MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); + rt.expect_create_actor(*MULTISIG_ACTOR_CODE_ID, expected_id_addr); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; // Expect a send to the multisig actor constructor rt.expect_send( - expected_id_addr.clone(), + expected_id_addr, METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), @@ -182,7 +182,7 @@ fn create_multisig_actor() { ); // Return should have been successful. Check the returned addresses - let exec_ret = exec_and_verify(&mut rt, MULTISIG_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret = exec_and_verify(&mut rt, *MULTISIG_ACTOR_CODE_ID, &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!( unique_address, exec_ret.robust_address, @@ -201,31 +201,31 @@ fn sending_constructor_failure() { // Only the storage power actor can create a miner rt.set_caller( - POWER_ACTOR_CODE_ID.clone(), - STORAGE_POWER_ACTOR_ADDR.clone(), + *POWER_ACTOR_CODE_ID, + *STORAGE_POWER_ACTOR_ADDR, ); // Assign new address for the storage actor miner let unique_address = Address::new_actor(b"miner"); - rt.new_actor_addr = Some(unique_address.clone()); + rt.new_actor_addr = Some(unique_address); // Create the next id address let expected_id_addr = Address::new_id(100); - rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); + rt.expect_create_actor(*MINER_ACTOR_CODE_ID, expected_id_addr); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; rt.expect_send( - expected_id_addr.clone(), + expected_id_addr, METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), Serialized::default(), - ExitCode::ErrIllegalState.clone(), + ExitCode::ErrIllegalState, ); - let error = exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params) + let error = exec_and_verify(&mut rt, *MINER_ACTOR_CODE_ID, &fake_params) .expect_err("sending constructor should have failed"); let error_exit_code = error.exit_code(); @@ -246,7 +246,7 @@ fn sending_constructor_failure() { } fn construct_and_verify(rt: &mut MockRuntime) { - rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR.clone()]); + rt.expect_validate_caller_addr(vec![*SYSTEM_ACTOR_ADDR]); let params = ConstructorParams { network_name: "mock".to_string(), }; diff --git a/vm/actor/tests/paych_actor_test.rs b/vm/actor/tests/paych_actor_test.rs index f00947c23604..377c41798156 100644 --- a/vm/actor/tests/paych_actor_test.rs +++ b/vm/actor/tests/paych_actor_test.rs @@ -70,12 +70,12 @@ mod paych_constructor { let payer_addr = Address::new_id(TEST_PAYER_ADDR); let caller_addr = Address::new_id(TEST_CALLER_ADDR); let mut actor_code_cids = HashMap::default(); - actor_code_cids.insert(payer_addr, ACCOUNT_ACTOR_CODE_ID.clone()); + actor_code_cids.insert(payer_addr, *ACCOUNT_ACTOR_CODE_ID); MockRuntime { receiver: paych_addr, caller: caller_addr, - caller_type: INIT_ACTOR_CODE_ID.clone(), + caller_type: *INIT_ACTOR_CODE_ID, actor_code_cids, ..Default::default() } @@ -86,14 +86,14 @@ mod paych_constructor { let caller_addr = Address::new_id(TEST_CALLER_ADDR); let mut rt = construct_runtime(); rt.actor_code_cids - .insert(caller_addr, ACCOUNT_ACTOR_CODE_ID.clone()); + .insert(caller_addr, *ACCOUNT_ACTOR_CODE_ID); construct_and_verify(&mut rt, Address::new_id(TEST_PAYER_ADDR), caller_addr); } #[test] fn actor_doesnt_exist_test() { let mut rt = construct_runtime(); - rt.expect_validate_caller_type(vec![INIT_ACTOR_CODE_ID.clone()]); + rt.expect_validate_caller_type(vec![*INIT_ACTOR_CODE_ID]); let params = ConstructorParams { to: Address::new_id(TEST_PAYCH_ADDR), from: Address::new_id(TEST_PAYER_ADDR), @@ -121,10 +121,10 @@ mod paych_constructor { } let test_cases: Vec = vec![TestCase { - paych_addr: paych_addr, - caller_code: INIT_ACTOR_CODE_ID.clone(), - new_actor_code: MULTISIG_ACTOR_CODE_ID.clone(), - payer_code: ACCOUNT_ACTOR_CODE_ID.clone(), + paych_addr, + caller_code: *INIT_ACTOR_CODE_ID, + new_actor_code: *MULTISIG_ACTOR_CODE_ID, + payer_code: *ACCOUNT_ACTOR_CODE_ID, expected_exit_code: ExitCode::ErrForbidden, }]; @@ -141,7 +141,7 @@ mod paych_constructor { ..Default::default() }; - rt.expect_validate_caller_type(vec![INIT_ACTOR_CODE_ID.clone()]); + rt.expect_validate_caller_type(vec![*INIT_ACTOR_CODE_ID]); let params = ConstructorParams { to: test_case.paych_addr, from: Address::new_id(10001), @@ -251,7 +251,7 @@ mod create_lane_tests { .unwrap(), TestCase::builder() .desc("fails if signature is not verified".to_string()) - .sig(sig.clone()) + .sig(sig) .verify_sig(false) .build() .unwrap(), @@ -268,13 +268,13 @@ mod create_lane_tests { println!("Test Description {}", test_case.desc); let mut actor_code_cids = HashMap::default(); - actor_code_cids.insert(payee_addr, ACCOUNT_ACTOR_CODE_ID.clone()); - actor_code_cids.insert(payer_addr, ACCOUNT_ACTOR_CODE_ID.clone()); + actor_code_cids.insert(payee_addr, *ACCOUNT_ACTOR_CODE_ID); + actor_code_cids.insert(payer_addr, *ACCOUNT_ACTOR_CODE_ID); let mut rt = MockRuntime { receiver: paych_addr, caller: init_actor_addr, - caller_type: INIT_ACTOR_CODE_ID.clone(), + caller_type: *INIT_ACTOR_CODE_ID, actor_code_cids, epoch: test_case.epoch, balance: paych_balance.clone(), @@ -301,7 +301,7 @@ mod create_lane_tests { rt.set_caller(test_case.target_code, payee_addr); rt.expect_validate_caller_addr(vec![payer_addr, payee_addr]); - if test_case.sig.is_some() && test_case.secret_preimage.len() == 0 { + if test_case.sig.is_some() && test_case.secret_preimage.is_empty() { let exp_exit_code = if !test_case.verify_sig { Err(Box::::from("bad signature".to_string())) } else { @@ -352,7 +352,7 @@ mod update_channel_state_redeem { let state: PState = rt.get_state().unwrap(); let payee_addr = Address::new_id(PAYEE_ID); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), payee_addr); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, payee_addr); rt.expect_validate_caller_addr(vec![state.from, state.to]); sv.amount = BigInt::from(9); @@ -369,7 +369,7 @@ mod update_channel_state_redeem { call( &mut rt, Method::UpdateChannelState as u64, - &Serialized::serialize(UpdateChannelStateParams::from(sv.clone())).unwrap(), + &Serialized::serialize(UpdateChannelStateParams::from(sv)).unwrap(), ); rt.verify(); @@ -394,7 +394,7 @@ mod update_channel_state_redeem { let state: PState = rt.get_state().unwrap(); let payee_addr = Address::new_id(PAYEE_ID); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), payee_addr); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, payee_addr); rt.expect_validate_caller_addr(vec![state.from, state.to]); let initial_amount = state.to_send; @@ -437,7 +437,7 @@ mod merge_tests { fn construct_runtime(num_lanes: u64) -> (MockRuntime, SignedVoucher, PState) { let (mut rt, sv) = require_create_cannel_with_lanes(num_lanes); let state: PState = rt.get_state().unwrap(); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from.clone()); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); (rt, sv, state) } @@ -453,7 +453,7 @@ mod merge_tests { expect_error( rt, Method::UpdateChannelState as u64, - &Serialized::serialize(UpdateChannelStateParams::from(sv.clone())).unwrap(), + &Serialized::serialize(UpdateChannelStateParams::from(sv)).unwrap(), exp_exit_code, ); rt.verify(); @@ -564,7 +564,7 @@ mod merge_tests { lane: tc.lane as usize, nonce: tc.merge, }]; - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); failure_end(&mut rt, sv, tc.exit); } } @@ -581,7 +581,7 @@ mod merge_tests { lane: 999, nonce: sv.nonce, }]; - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); rt.expect_verify_signature(ExpectedVerifySig { plaintext: sv.signing_bytes().unwrap(), @@ -612,13 +612,13 @@ mod update_channel_state_extra { let state: PState = rt.get_state().unwrap(); let other_addr = Address::new_id(OTHER_ADDR); let fake_params = [1, 2, 3, 4]; - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); sv.extra = Some(ModVerifyParams { actor: other_addr, method: Method::UpdateChannelState as u64, - data: Serialized::serialize(fake_params.clone()).unwrap(), + data: Serialized::serialize(fake_params).unwrap(), }); rt.expect_verify_signature(ExpectedVerifySig { sig: sv.clone().signature.unwrap(), @@ -648,7 +648,7 @@ mod update_channel_state_extra { call( &mut rt, Method::UpdateChannelState as u64, - &Serialized::serialize(UpdateChannelStateParams::from(sv.clone())).unwrap(), + &Serialized::serialize(UpdateChannelStateParams::from(sv)).unwrap(), ); rt.verify(); } @@ -660,7 +660,7 @@ mod update_channel_state_extra { expect_error( &mut rt, Method::UpdateChannelState as u64, - &Serialized::serialize(UpdateChannelStateParams::from(sv.clone())).unwrap(), + &Serialized::serialize(UpdateChannelStateParams::from(sv)).unwrap(), ExitCode::ErrPlaceholder, ); rt.verify(); @@ -673,7 +673,7 @@ fn update_channel_settling() { rt.epoch = 10; let state: PState = rt.get_state().unwrap(); rt.expect_validate_caller_addr(vec![state.from, state.to]); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); call(&mut rt, Method::Settle as u64, &Serialized::default()); let exp_settling_at = SETTLE_DELAY + 10; @@ -773,7 +773,7 @@ mod secret_preimage { rt.expect_validate_caller_addr(vec![state.from, state.to]); rt.expect_verify_signature(ExpectedVerifySig { - sig: sv.signature.clone().unwrap(), + sig: sv.signature.unwrap(), signer: state.to, plaintext: ucp.sv.signing_bytes().unwrap(), result: Ok(()), @@ -797,7 +797,7 @@ mod actor_settle { let (mut rt, _sv) = require_create_cannel_with_lanes(1); rt.epoch = EP; let mut state: PState = rt.get_state().unwrap(); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); call(&mut rt, Method::Settle as u64, &Serialized::default()); @@ -813,7 +813,7 @@ mod actor_settle { let (mut rt, _sv) = require_create_cannel_with_lanes(1); rt.epoch = EP; let state: PState = rt.get_state().unwrap(); - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); call(&mut rt, Method::Settle as u64, &Serialized::default()); @@ -853,7 +853,7 @@ mod actor_settle { assert_eq!(state.min_settle_height, ucp.sv.min_settle_height); // Settle. - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); call(&mut rt, Method::Settle as u64, &Serialized::default()); @@ -873,7 +873,7 @@ mod actor_collect { let st: PState = rt.get_state().unwrap(); // Settle. - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), st.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, st.from); rt.expect_validate_caller_addr(vec![st.from, st.to]); call(&mut rt, Method::Settle as u64, &Default::default()); @@ -894,7 +894,7 @@ mod actor_collect { ); // Collect. - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), st.to); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, st.to); rt.expect_validate_caller_addr(vec![st.from, st.to]); rt.expect_delete_actor(st.from); let res = call(&mut rt, Method::Collect as u64, &Default::default()); @@ -930,7 +930,7 @@ mod actor_collect { let mut state: PState = rt.get_state().unwrap(); if !tc.dont_settle { - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); call(&mut rt, Method::Settle as u64, &Serialized::default()); state = rt.get_state().unwrap(); @@ -949,7 +949,7 @@ mod actor_collect { ); // Collect. - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), state.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, state.from); rt.expect_validate_caller_addr(vec![state.from, state.to]); expect_error( &mut rt, @@ -970,13 +970,13 @@ fn require_create_cannel_with_lanes(num_lanes: u64) -> (MockRuntime, SignedVouch let curr_epoch = 2; let mut actor_code_cids = HashMap::default(); - actor_code_cids.insert(payee_addr, ACCOUNT_ACTOR_CODE_ID.clone()); - actor_code_cids.insert(payer_addr, ACCOUNT_ACTOR_CODE_ID.clone()); + actor_code_cids.insert(payee_addr, *ACCOUNT_ACTOR_CODE_ID); + actor_code_cids.insert(payer_addr, *ACCOUNT_ACTOR_CODE_ID); let mut rt = MockRuntime { receiver: paych_addr, caller: *INIT_ACTOR_ADDR, - caller_type: INIT_ACTOR_CODE_ID.clone(), + caller_type: *INIT_ACTOR_CODE_ID, actor_code_cids, received, balance, @@ -1004,7 +1004,7 @@ fn require_create_cannel_with_lanes(num_lanes: u64) -> (MockRuntime, SignedVouch } fn require_add_new_lane(rt: &mut MockRuntime, param: LaneParams) -> SignedVoucher { - let payee_addr = Address::new_id(103 as u64); + let payee_addr = Address::new_id(103_u64); let sig = Signature::new_bls(vec![0, 1, 2, 3, 4, 5, 6, 7]); let mut sv = SignedVoucher { time_lock_min: param.epoch_num, @@ -1019,10 +1019,10 @@ fn require_add_new_lane(rt: &mut MockRuntime, param: LaneParams) -> SignedVouche min_settle_height: Default::default(), merges: Default::default(), }; - rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), param.from); + rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, param.from); rt.expect_validate_caller_addr(vec![param.from, param.to]); rt.expect_verify_signature(ExpectedVerifySig { - sig: sig.clone(), + sig, signer: payee_addr, plaintext: sv.signing_bytes().unwrap(), result: Ok(()), @@ -1042,7 +1042,7 @@ fn construct_and_verify(rt: &mut MockRuntime, sender: Address, receiver: Address from: sender, to: receiver, }; - rt.expect_validate_caller_type(vec![INIT_ACTOR_CODE_ID.clone()]); + rt.expect_validate_caller_type(vec![*INIT_ACTOR_CODE_ID]); call( rt, METHOD_CONSTRUCTOR, diff --git a/vm/actor/tests/reward_actor_test.rs b/vm/actor/tests/reward_actor_test.rs index 20637d1bc930..1d785d86b881 100644 --- a/vm/actor/tests/reward_actor_test.rs +++ b/vm/actor/tests/reward_actor_test.rs @@ -321,10 +321,10 @@ fn construct_and_verify(curr_power: &StoragePower) -> MockRuntime { let mut rt = MockRuntime { receiver: *REWARD_ACTOR_ADDR, caller: *SYSTEM_ACTOR_ADDR, - caller_type: SYSTEM_ACTOR_CODE_ID.clone(), + caller_type: *SYSTEM_ACTOR_CODE_ID, ..Default::default() }; - rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR.clone()]); + rt.expect_validate_caller_addr(vec![*SYSTEM_ACTOR_ADDR]); let ret = rt .call( &*REWARD_ACTOR_CODE_ID, @@ -405,7 +405,7 @@ fn this_epoch_reward(rt: &mut MockRuntime) -> ThisEpochRewardReturn { } fn update_network_kpi(rt: &mut MockRuntime, curr_raw_power: &StoragePower) { - rt.set_caller(POWER_ACTOR_CODE_ID.clone(), *STORAGE_POWER_ACTOR_ADDR); + rt.set_caller(*POWER_ACTOR_CODE_ID, *STORAGE_POWER_ACTOR_ADDR); rt.expect_validate_caller_addr(vec![*STORAGE_POWER_ACTOR_ADDR]); let params = &Serialized::serialize(BigIntSer(&curr_raw_power)).unwrap(); diff --git a/vm/address/src/lib.rs b/vm/address/src/lib.rs index 1fdb8d657460..d5b9ff691c04 100644 --- a/vm/address/src/lib.rs +++ b/vm/address/src/lib.rs @@ -148,7 +148,7 @@ impl Address { } /// Returns encoded bytes of Address - pub fn to_bytes(&self) -> Vec { + pub fn to_bytes(self) -> Vec { self.payload.to_bytes() } diff --git a/vm/address/src/payload.rs b/vm/address/src/payload.rs index 7214f70ce70d..edd23a6ffe19 100644 --- a/vm/address/src/payload.rs +++ b/vm/address/src/payload.rs @@ -61,10 +61,10 @@ pub enum Payload { impl Payload { /// Returns encoded bytes of Address without the protocol byte. - pub fn to_raw_bytes(&self) -> Vec { + pub fn to_raw_bytes(self) -> Vec { use Payload::*; match self { - ID(i) => to_leb_bytes(*i).unwrap(), + ID(i) => to_leb_bytes(i).unwrap(), Secp256k1(arr) => arr.to_vec(), Actor(arr) => arr.to_vec(), BLS(arr) => arr.to_vec(), @@ -72,10 +72,10 @@ impl Payload { } /// Returns encoded bytes of Address including the protocol byte. - pub(crate) fn to_bytes(&self) -> Vec { + pub(crate) fn to_bytes(self) -> Vec { use Payload::*; let mut bz = match self { - ID(i) => to_leb_bytes(*i).unwrap(), + ID(i) => to_leb_bytes(i).unwrap(), Secp256k1(arr) => arr.to_vec(), Actor(arr) => arr.to_vec(), BLS(arr) => arr.to_vec(), diff --git a/vm/address/tests/address_test.rs b/vm/address/tests/address_test.rs index 05e36af8783c..d0b72a1e3ed3 100644 --- a/vm/address/tests/address_test.rs +++ b/vm/address/tests/address_test.rs @@ -46,7 +46,7 @@ fn generate_validate_checksum() { let cksm = checksum(&data); assert_eq!(cksm.len(), 4); assert_eq!(validate_checksum(&data, cksm.clone()), true); - assert_eq!(validate_checksum(&other_data, cksm.clone()), false); + assert_eq!(validate_checksum(&other_data, cksm), false); } struct AddressTestVec<'a> { @@ -344,19 +344,19 @@ fn invalid_byte_addresses() { let secp_vec = vec![1]; let mut secp_l = secp_vec.clone(); secp_l.resize(PAYLOAD_HASH_LEN + 2, 0); - let mut secp_s = secp_vec.clone(); + let mut secp_s = secp_vec; secp_s.resize(PAYLOAD_HASH_LEN, 0); let actor_vec = vec![2]; let mut actor_l = actor_vec.clone(); actor_l.resize(PAYLOAD_HASH_LEN + 2, 0); - let mut actor_s = actor_vec.clone(); + let mut actor_s = actor_vec; actor_s.resize(PAYLOAD_HASH_LEN, 0); let bls_vec = vec![3]; let mut bls_l = bls_vec.clone(); bls_l.resize(BLS_PUB_LEN + 2, 0); - let mut bls_s = bls_vec.clone(); + let mut bls_s = bls_vec; bls_s.resize(BLS_PUB_LEN, 0); let test_vectors = &[ @@ -532,13 +532,13 @@ fn address_hashmap() { // insert and validate value set let mut hm: HashMap = HashMap::new(); let h1 = Address::new_id(1); - hm.insert(h1.clone(), 1); + hm.insert(h1, 1); assert_eq!(hm.get(&h1).unwrap(), &1); // insert other value let h2 = Address::new_id(2); assert!(hm.get(&h2).is_none()); - hm.insert(h2.clone(), 2); + hm.insert(h2, 2); assert_eq!(hm.get(&h2).unwrap(), &2); // validate original value was not overriden @@ -586,7 +586,7 @@ fn invalid_strings_tests() { b"f\xF0\x90\x80mk3zcefvlgpay4f32c5vmruk5gqig6dumc7pz6q", ]; for s in non_utf8_unchecked { - let st = unsafe { std::str::from_utf8_unchecked(s.as_ref()) }; + let st = unsafe { std::str::from_utf8_unchecked(s) }; assert!(Address::from_str(st).is_err()); } } diff --git a/vm/interpreter/src/default_runtime.rs b/vm/interpreter/src/default_runtime.rs index 0c181c2248eb..77f8ca208e06 100644 --- a/vm/interpreter/src/default_runtime.rs +++ b/vm/interpreter/src/default_runtime.rs @@ -965,10 +965,8 @@ where } }; - // (3) return if no consensus fault by now - if cf.is_none() { - Ok(cf) - } else { + // (3) return if no consensus fault + if cf.is_some() { // (4) expensive final checks // check blocks are properly signed by their respective miner @@ -976,9 +974,8 @@ where // which itself is signed, so it was willingly included by the miner self.verify_block_signature(&bh_1)?; self.verify_block_signature(&bh_2)?; - - Ok(cf) } + Ok(cf) } fn batch_verify_seals( diff --git a/vm/interpreter/tests/transfer_test.rs b/vm/interpreter/tests/transfer_test.rs index 35779990504b..6453c55a548a 100644 --- a/vm/interpreter/tests/transfer_test.rs +++ b/vm/interpreter/tests/transfer_test.rs @@ -66,7 +66,7 @@ fn transfer_test() { .unwrap(); // Create and save init actor - let init_state = init::State::new(e_cid.clone(), "test".to_owned()); + let init_state = init::State::new(e_cid, "test".to_owned()); let state_cid = state .store() .put(&init_state, Blake2b256) @@ -74,12 +74,12 @@ fn transfer_test() { .unwrap(); let act_s = ActorState::new( - INIT_ACTOR_CODE_ID.clone(), - state_cid.clone(), + *INIT_ACTOR_CODE_ID, + state_cid, Default::default(), 1, ); - state.set_actor(&INIT_ACTOR_ADDR, act_s.clone()).unwrap(); + state.set_actor(&INIT_ACTOR_ADDR, act_s).unwrap(); let actor_addr_1 = Address::new_id(100); let actor_addr_2 = Address::new_id(200); @@ -88,7 +88,7 @@ fn transfer_test() { .store() .put( &account::State { - address: actor_addr_1.clone(), + address: actor_addr_1, }, Identity, ) @@ -99,21 +99,21 @@ fn transfer_test() { .store() .put( &account::State { - address: actor_addr_2.clone(), + address: actor_addr_2, }, Identity, ) .map_err(|e| e.to_string()) .unwrap(); let actor_state_1 = ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - actor_state_cid_1.clone(), + *ACCOUNT_ACTOR_CODE_ID, + actor_state_cid_1, 10000u64.into(), 0, ); let actor_state_2 = ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - actor_state_cid_2.clone(), + *ACCOUNT_ACTOR_CODE_ID, + actor_state_cid_2, 1u64.into(), 0, ); @@ -124,8 +124,8 @@ fn transfer_test() { state.set_actor(&actor_addr_2, actor_state_2).unwrap(); let message = UnsignedMessage::builder() - .to(actor_addr_1.clone()) - .from(actor_addr_2.clone()) + .to(actor_addr_1) + .from(actor_addr_2) .method_num(2) .value(1u8.into()) .gas_limit(10000000) @@ -143,7 +143,7 @@ fn transfer_test() { 0, &message, 0, - actor_addr_2.clone(), + actor_addr_2, 0, 0, 0, diff --git a/vm/message/src/unsigned_message.rs b/vm/message/src/unsigned_message.rs index a29428748f9f..311c649432d5 100644 --- a/vm/message/src/unsigned_message.rs +++ b/vm/message/src/unsigned_message.rs @@ -156,18 +156,7 @@ impl<'de> Deserialize<'de> for UnsignedMessage { method_num, params, ) = Deserialize::deserialize(deserializer)?; - Ok(Self { - version, - to, - from, - sequence, - value, - gas_limit, - gas_fee_cap, - gas_premium, - method_num, - params, - }) + Ok(Self { version, from, to, sequence, value, method_num, params, gas_limit, gas_fee_cap, gas_premium }) } } diff --git a/vm/src/actor_state.rs b/vm/src/actor_state.rs index f3ec1a64cdff..62e10042fa5a 100644 --- a/vm/src/actor_state.rs +++ b/vm/src/actor_state.rs @@ -23,12 +23,7 @@ pub struct ActorState { impl ActorState { /// Constructor for actor state pub fn new(code: Cid, state: Cid, balance: TokenAmount, sequence: u64) -> Self { - Self { - code, - state, - balance, - sequence, - } + Self { code, state, sequence, balance } } /// Safely deducts funds from an Actor pub fn deduct_funds(&mut self, amt: &TokenAmount) -> Result<(), String> { diff --git a/vm/state_tree/tests/state_tree_tests.rs b/vm/state_tree/tests/state_tree_tests.rs index bb14b04d300f..a007cc64acf4 100644 --- a/vm/state_tree/tests/state_tree_tests.rs +++ b/vm/state_tree/tests/state_tree_tests.rs @@ -29,7 +29,7 @@ fn get_set_cache() { // test address not in cache assert_eq!(tree.get_actor(&addr).unwrap(), None); // test successful insert - assert!(tree.set_actor(&addr, act_s.clone()).is_ok()); + assert!(tree.set_actor(&addr, act_s).is_ok()); // test inserting with different data assert!(tree.set_actor(&addr, act_a.clone()).is_ok()); // Assert insert with same data returns ok @@ -61,7 +61,7 @@ fn get_set_non_id() { .flush() .unwrap(); - let init_state = init::State::new(e_cid.clone(), "test".to_owned()); + let init_state = init::State::new(e_cid, "test".to_owned()); let state_cid = tree .store() .put(&init_state, Blake2b256) @@ -70,13 +70,13 @@ fn get_set_non_id() { let act_s = ActorState::new( *INIT_ACTOR_CODE_ID, - state_cid.clone(), + state_cid, Default::default(), 1, ); tree.snapshot().unwrap(); - tree.set_actor(&INIT_ACTOR_ADDR, act_s.clone()).unwrap(); + tree.set_actor(&INIT_ACTOR_ADDR, act_s).unwrap(); // Test mutate function tree.mutate_actor(&INIT_ACTOR_ADDR, |mut actor| { @@ -118,8 +118,8 @@ fn test_snapshots() { tree.set_actor( &addresses[0], ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1, ), @@ -129,8 +129,8 @@ fn test_snapshots() { tree.set_actor( &addresses[1], ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1, ), @@ -139,8 +139,8 @@ fn test_snapshots() { tree.set_actor( &addresses[2], ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1, ), @@ -152,8 +152,8 @@ fn test_snapshots() { assert_eq!( tree.get_actor(&addresses[0]).unwrap().unwrap(), ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1 ) @@ -161,8 +161,8 @@ fn test_snapshots() { assert_eq!( tree.get_actor(&addresses[1]).unwrap().unwrap(), ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1 ) @@ -171,8 +171,8 @@ fn test_snapshots() { assert_eq!( tree.get_actor(&addresses[2]).unwrap().unwrap(), ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1 ) @@ -192,8 +192,8 @@ fn revert_snapshot() { tree.set_actor( &addr, ActorState::new( - ACCOUNT_ACTOR_CODE_ID.clone(), - ACCOUNT_ACTOR_CODE_ID.clone(), + *ACCOUNT_ACTOR_CODE_ID, + *ACCOUNT_ACTOR_CODE_ID, BigInt::from(55), 1, ),