diff --git a/Cargo.lock b/Cargo.lock index ddf8c2ef7..06734143d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -915,7 +915,7 @@ dependencies = [ [[package]] name = "frc42_dispatch" version = "1.0.0" -source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#f11abfa0c7d2b6c0b83de01ab205927360555ef1" +source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#7e066d986dd4f9571cc17c7e8dd3405c89ca33cc" dependencies = [ "frc42_hasher", "frc42_macros", @@ -928,7 +928,7 @@ dependencies = [ [[package]] name = "frc42_hasher" version = "1.0.0" -source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#f11abfa0c7d2b6c0b83de01ab205927360555ef1" +source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#7e066d986dd4f9571cc17c7e8dd3405c89ca33cc" dependencies = [ "fvm_sdk", "fvm_shared", @@ -938,7 +938,7 @@ dependencies = [ [[package]] name = "frc42_macros" version = "1.0.0" -source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#f11abfa0c7d2b6c0b83de01ab205927360555ef1" +source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#7e066d986dd4f9571cc17c7e8dd3405c89ca33cc" dependencies = [ "blake2b_simd", "frc42_hasher", @@ -950,7 +950,7 @@ dependencies = [ [[package]] name = "frc46_token" version = "1.1.0" -source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#f11abfa0c7d2b6c0b83de01ab205927360555ef1" +source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#7e066d986dd4f9571cc17c7e8dd3405c89ca33cc" dependencies = [ "anyhow", "cid", @@ -1076,7 +1076,7 @@ dependencies = [ [[package]] name = "fvm_actor_utils" version = "0.1.0" -source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#f11abfa0c7d2b6c0b83de01ab205927360555ef1" +source = "git+https://github.com/filecoin-project/filecoin-actor-utils?branch=asr/ipld-block-master#7e066d986dd4f9571cc17c7e8dd3405c89ca33cc" dependencies = [ "anyhow", "cid", @@ -1094,7 +1094,7 @@ dependencies = [ [[package]] name = "fvm_ipld_amt" version = "0.4.2" -source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#1c8a85882c3c476897164cc45c4094ee843adece" +source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#3fc26620b264fbc84d42ff5a0573119c28250938" dependencies = [ "ahash", "anyhow", @@ -1122,7 +1122,7 @@ dependencies = [ [[package]] name = "fvm_ipld_blockstore" version = "0.1.1" -source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#1c8a85882c3c476897164cc45c4094ee843adece" +source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#3fc26620b264fbc84d42ff5a0573119c28250938" dependencies = [ "anyhow", "cid", @@ -1147,7 +1147,7 @@ dependencies = [ [[package]] name = "fvm_ipld_encoding" version = "0.2.2" -source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#1c8a85882c3c476897164cc45c4094ee843adece" +source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#3fc26620b264fbc84d42ff5a0573119c28250938" dependencies = [ "anyhow", "cid", @@ -1181,7 +1181,7 @@ dependencies = [ [[package]] name = "fvm_ipld_hamt" version = "0.5.1" -source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#1c8a85882c3c476897164cc45c4094ee843adece" +source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#3fc26620b264fbc84d42ff5a0573119c28250938" dependencies = [ "anyhow", "byteorder", @@ -1201,7 +1201,7 @@ dependencies = [ [[package]] name = "fvm_sdk" version = "2.0.0" -source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#1c8a85882c3c476897164cc45c4094ee843adece" +source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#3fc26620b264fbc84d42ff5a0573119c28250938" dependencies = [ "cid", "fvm_ipld_encoding 0.2.2", @@ -1215,7 +1215,7 @@ dependencies = [ [[package]] name = "fvm_shared" version = "2.0.0" -source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#1c8a85882c3c476897164cc45c4094ee843adece" +source = "git+https://github.com/filecoin-project/ref-fvm?branch=asr/ipld-block-v2#3fc26620b264fbc84d42ff5a0573119c28250938" dependencies = [ "anyhow", "blake2b_simd", @@ -1739,9 +1739,9 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" [[package]] name = "serde" -version = "1.0.149" +version = "1.0.150" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "256b9932320c590e707b94576e3cc1f7c9024d0ee6612dfbcf1cb106cbe8e055" +checksum = "e326c9ec8042f1b5da33252c8a37e9ffbd2c9bef0155215b6e6c80c790e05f91" dependencies = [ "serde_derive", ] @@ -1766,9 +1766,9 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.149" +version = "1.0.150" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4eae9b04cbffdfd550eb462ed33bc6a1b68c935127d008b27444d08380f94e4" +checksum = "42a3df25b0713732468deadad63ab9da1f1fd75a48a15024b50363f128db627e" dependencies = [ "proc-macro2", "quote", diff --git a/actors/account/tests/account_actor_test.rs b/actors/account/tests/account_actor_test.rs index 7b1707c43..a0cfec7fa 100644 --- a/actors/account/tests/account_actor_test.rs +++ b/actors/account/tests/account_actor_test.rs @@ -29,7 +29,7 @@ fn construction() { if exit_code.is_success() { rt.call::( Method::Constructor as MethodNum, - Some(IpldBlock::serialize_cbor(&addr).unwrap()), + IpldBlock::serialize_cbor(&addr).unwrap(), ) .unwrap(); @@ -47,7 +47,7 @@ fn construction() { } else { expect_abort( exit_code, - rt.call::(1, Some(IpldBlock::serialize_cbor(&addr).unwrap())), + rt.call::(1, IpldBlock::serialize_cbor(&addr).unwrap()), ) } rt.verify(); @@ -75,20 +75,18 @@ fn token_receiver() { let param = Address::new_secp256k1(&[2; fvm_shared::address::SECP_PUB_LEN]).unwrap(); rt.call::( Method::Constructor as MethodNum, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ) .unwrap(); rt.expect_validate_caller_any(); let ret = rt.call::( Method::UniversalReceiverHook as MethodNum, - Some( - IpldBlock::serialize_cbor(&UniversalReceiverParams { - type_: 0, - payload: RawBytes::new(vec![1, 2, 3]), - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&UniversalReceiverParams { + type_: 0, + payload: RawBytes::new(vec![1, 2, 3]), + }) + .unwrap(), ); assert!(ret.is_ok()); assert_eq!(RawBytes::default(), ret.unwrap()); @@ -112,18 +110,16 @@ fn authenticate_message() { let addr = Address::new_secp256k1(&[2; fvm_shared::address::SECP_PUB_LEN]).unwrap(); rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); - rt.call::(1, Some(IpldBlock::serialize_cbor(&addr).unwrap())).unwrap(); + rt.call::(1, IpldBlock::serialize_cbor(&addr).unwrap()).unwrap(); let state: State = rt.get_state(); assert_eq!(state.address, addr); - let params = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: vec![], - message: vec![], - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: vec![], + message: vec![], + }) + .unwrap(); rt.expect_validate_caller_any(); rt.expect_verify_signature(ExpectedVerifySig { diff --git a/actors/cron/tests/cron_actor_test.rs b/actors/cron/tests/cron_actor_test.rs index 98d31f9b2..9b0dd49c0 100644 --- a/actors/cron/tests/cron_actor_test.rs +++ b/actors/cron/tests/cron_actor_test.rs @@ -118,7 +118,7 @@ fn epoch_tick_with_entries() { fn construct_and_verify(rt: &mut MockRuntime, params: &ConstructorParams) { rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); - let ret = rt.call::(1, Some(IpldBlock::serialize_cbor(¶ms).unwrap())).unwrap(); + let ret = rt.call::(1, IpldBlock::serialize_cbor(¶ms).unwrap()).unwrap(); assert_eq!(RawBytes::default(), ret); rt.verify(); } diff --git a/actors/datacap/tests/datacap_actor_test.rs b/actors/datacap/tests/datacap_actor_test.rs index e2f62fd3c..d6bcfb91e 100644 --- a/actors/datacap/tests/datacap_actor_test.rs +++ b/actors/datacap/tests/datacap_actor_test.rs @@ -75,7 +75,7 @@ mod mint { "caller address", rt.call::( Method::Mint as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); h.check_state(&rt); @@ -218,7 +218,7 @@ mod destroy { "caller address", rt.call::( Method::Destroy as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); diff --git a/actors/datacap/tests/harness/mod.rs b/actors/datacap/tests/harness/mod.rs index d2a60f7ea..c381fabf8 100644 --- a/actors/datacap/tests/harness/mod.rs +++ b/actors/datacap/tests/harness/mod.rs @@ -47,7 +47,7 @@ impl Harness { let ret = rt .call::( Method::Constructor as MethodNum, - Some(IpldBlock::serialize_cbor(registry).unwrap()), + IpldBlock::serialize_cbor(registry).unwrap(), ) .unwrap(); @@ -86,7 +86,7 @@ impl Harness { rt.expect_send( *to, frc42_dispatch::method_hash!("Receive"), - Some(IpldBlock::serialize_cbor(&hook_params).unwrap()), + IpldBlock::serialize_cbor(&hook_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -96,7 +96,7 @@ impl Harness { rt.set_caller(*VERIFREG_ACTOR_CODE_ID, VERIFIED_REGISTRY_ACTOR_ADDR); let ret = rt.call::( Method::Mint as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -116,7 +116,7 @@ impl Harness { rt.set_caller(*VERIFREG_ACTOR_CODE_ID, VERIFIED_REGISTRY_ACTOR_ADDR); let ret = rt.call::( Method::Destroy as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -153,7 +153,7 @@ impl Harness { rt.expect_send( *to, frc42_dispatch::method_hash!("Receive"), - Some(IpldBlock::serialize_cbor(&hook_params).unwrap()), + IpldBlock::serialize_cbor(&hook_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -162,7 +162,7 @@ impl Harness { let params = TransferParams { to: *to, amount: amount.clone(), operator_data }; let ret = rt.call::( Method::Transfer as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -200,7 +200,7 @@ impl Harness { rt.expect_send( *to, frc42_dispatch::method_hash!("Receive"), - Some(IpldBlock::serialize_cbor(&hook_params).unwrap()), + IpldBlock::serialize_cbor(&hook_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -210,7 +210,7 @@ impl Harness { TransferFromParams { to: *to, from: *from, amount: amount.clone(), operator_data }; let ret = rt.call::( Method::TransferFrom as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); diff --git a/actors/init/tests/init_actor_test.rs b/actors/init/tests/init_actor_test.rs index 3416de6b2..ead205770 100644 --- a/actors/init/tests/init_actor_test.rs +++ b/actors/init/tests/init_actor_test.rs @@ -73,7 +73,7 @@ fn repeated_robust_address() { rt.expect_send( expected_id_addr, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(&fake_params).unwrap()), + IpldBlock::serialize_cbor(&fake_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -99,7 +99,7 @@ fn repeated_robust_address() { let ret = rt.call::( Method::Exec as u64, - Some(IpldBlock::serialize_cbor(&exec_params).unwrap()), + IpldBlock::serialize_cbor(&exec_params).unwrap(), ); rt.verify(); @@ -138,7 +138,7 @@ fn create_2_payment_channels() { rt.expect_send( expected_id_addr, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(&fake_params).unwrap()), + IpldBlock::serialize_cbor(&fake_params).unwrap(), balance, RawBytes::default(), ExitCode::OK, @@ -180,7 +180,7 @@ fn create_storage_miner() { rt.expect_send( expected_id_addr, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(&fake_params).unwrap()), + IpldBlock::serialize_cbor(&fake_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -231,7 +231,7 @@ fn create_multisig_actor() { rt.expect_send( expected_id_addr, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(&fake_params).unwrap()), + IpldBlock::serialize_cbor(&fake_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -266,7 +266,7 @@ fn sending_constructor_failure() { rt.expect_send( expected_id_addr, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(&fake_params).unwrap()), + IpldBlock::serialize_cbor(&fake_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::USR_ILLEGAL_STATE, @@ -294,7 +294,7 @@ fn construct_and_verify(rt: &mut MockRuntime) { rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); let params = ConstructorParams { network_name: "mock".to_string() }; let ret = rt - .call::(METHOD_CONSTRUCTOR, Some(IpldBlock::serialize_cbor(¶ms).unwrap())) + .call::(METHOD_CONSTRUCTOR, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap(); assert_eq!(RawBytes::default(), ret); @@ -324,10 +324,8 @@ where let exec_params = ExecParams { code_cid: code_id, constructor_params: RawBytes::serialize(params).unwrap() }; - let ret = rt.call::( - Method::Exec as u64, - Some(IpldBlock::serialize_cbor(&exec_params).unwrap()), - ); + let ret = + rt.call::(Method::Exec as u64, IpldBlock::serialize_cbor(&exec_params).unwrap()); rt.verify(); check_state(rt); diff --git a/actors/market/src/lib.rs b/actors/market/src/lib.rs index 323da884d..76eee95bb 100644 --- a/actors/market/src/lib.rs +++ b/actors/market/src/lib.rs @@ -294,7 +294,7 @@ impl Actor { .send( &DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::TRANSFER_FROM_METHOD as u64, - Some(IpldBlock::serialize_cbor(¶ms)?), + IpldBlock::serialize_cbor(¶ms)?, TokenAmount::zero(), ) .and_then(|ret| datacap_transfer_response(&ret)); @@ -1053,10 +1053,10 @@ fn deal_proposal_is_internally_valid( rt.send( &proposal.proposal.client, ext::account::AUTHENTICATE_MESSAGE_METHOD, - Some(IpldBlock::serialize_cbor(&ext::account::AuthenticateMessageParams { + IpldBlock::serialize_cbor(&ext::account::AuthenticateMessageParams { signature: signature_bytes, message: proposal_bytes, - })?), + })?, TokenAmount::zero(), ) .map_err(|e| e.wrap("proposal authentication failed"))?; diff --git a/actors/market/tests/activate_deal_failures.rs b/actors/market/tests/activate_deal_failures.rs index 82ae62fbd..a64c34fc6 100644 --- a/actors/market/tests/activate_deal_failures.rs +++ b/actors/market/tests/activate_deal_failures.rs @@ -33,7 +33,7 @@ fn fail_when_caller_is_not_the_provider_of_the_deal() { ExitCode::USR_FORBIDDEN, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -52,7 +52,7 @@ fn fail_when_caller_is_not_a_storage_miner_actor() { ExitCode::USR_FORBIDDEN, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -71,7 +71,7 @@ fn fail_when_deal_has_not_been_published_before() { ExitCode::USR_NOT_FOUND, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -102,7 +102,7 @@ fn fail_when_deal_has_already_been_activated() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); diff --git a/actors/market/tests/compute_data_commitment.rs b/actors/market/tests/compute_data_commitment.rs index 8bef71e14..0bf1eace8 100644 --- a/actors/market/tests/compute_data_commitment.rs +++ b/actors/market/tests/compute_data_commitment.rs @@ -71,7 +71,7 @@ mod compute_data_commitment { let ret: ComputeDataCommitmentReturn = rt .call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ) .unwrap() .deserialize() @@ -104,7 +104,7 @@ mod compute_data_commitment { let ret: ComputeDataCommitmentReturn = rt .call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ) .unwrap() .deserialize() @@ -178,7 +178,7 @@ mod compute_data_commitment { let ret: ComputeDataCommitmentReturn = rt .call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ) .unwrap() .deserialize() @@ -206,7 +206,7 @@ mod compute_data_commitment { ExitCode::USR_NOT_FOUND, rt.call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ), ); check_state(&rt); @@ -246,7 +246,7 @@ mod compute_data_commitment { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ), ); check_state(&rt); @@ -292,7 +292,7 @@ mod compute_data_commitment { ExitCode::USR_NOT_FOUND, rt.call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ), ); check_state(&rt); @@ -343,7 +343,7 @@ mod compute_data_commitment { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::ComputeDataCommitment as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ), ); check_state(&rt); diff --git a/actors/market/tests/cron_tick_timedout_deals.rs b/actors/market/tests/cron_tick_timedout_deals.rs index 0ebea3791..ce583a67c 100644 --- a/actors/market/tests/cron_tick_timedout_deals.rs +++ b/actors/market/tests/cron_tick_timedout_deals.rs @@ -88,13 +88,11 @@ fn publishing_timed_out_deal_again_should_work_after_cron_tick_as_it_should_no_l expect_provider_control_address(&mut rt, PROVIDER_ADDR, OWNER_ADDR, WORKER_ADDR); expect_query_network_info(&mut rt); rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, WORKER_ADDR); - let auth_param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf.to_vec(), - message: buf.to_vec(), - }) - .unwrap(), - ); + let auth_param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf.to_vec(), + message: buf.to_vec(), + }) + .unwrap(); rt.expect_send( deal_proposal2.client, @@ -109,7 +107,7 @@ fn publishing_timed_out_deal_again_should_work_after_cron_tick_as_it_should_no_l ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); diff --git a/actors/market/tests/harness.rs b/actors/market/tests/harness.rs index 6062476f1..793b106a1 100644 --- a/actors/market/tests/harness.rs +++ b/actors/market/tests/harness.rs @@ -169,9 +169,9 @@ pub fn add_provider_funds(rt: &mut MockRuntime, amount: TokenAmount, addrs: &Min RawBytes::default(), rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&addrs.provider).unwrap()), + IpldBlock::serialize_cbor(&addrs.provider).unwrap(), ) - .unwrap() + .unwrap(), ); rt.verify(); rt.add_balance(amount); @@ -185,10 +185,7 @@ pub fn add_participant_funds(rt: &mut MockRuntime, addr: Address, amount: TokenA rt.expect_validate_caller_type((*CALLER_TYPES_SIGNABLE).to_vec()); assert!(rt - .call::( - Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&addr).unwrap()), - ) + .call::(Method::AddBalance as u64, IpldBlock::serialize_cbor(&addr).unwrap()) .is_ok()); rt.verify(); @@ -221,7 +218,7 @@ pub fn withdraw_provider_balance( let ret: WithdrawBalanceReturn = rt .call::( Method::WithdrawBalance as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() @@ -257,7 +254,7 @@ pub fn withdraw_client_balance( let ret: WithdrawBalanceReturn = rt .call::( Method::WithdrawBalance as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() @@ -297,7 +294,7 @@ pub fn activate_deals_raw( let ret = rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -483,13 +480,11 @@ pub fn publish_deals( params.deals.push(client_proposal); // expect an invocation of authenticate_message to verify the above signature - let param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: "does not matter".as_bytes().to_vec(), - message: buf.to_vec(), - }) - .unwrap(), - ); + let param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: "does not matter".as_bytes().to_vec(), + message: buf.to_vec(), + }) + .unwrap(); rt.expect_send( deal.client, ext::account::AUTHENTICATE_MESSAGE_METHOD as u64, @@ -528,7 +523,7 @@ pub fn publish_deals( rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::TRANSFER_FROM_METHOD as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), serialize( &TransferFromReturn { @@ -549,7 +544,7 @@ pub fn publish_deals( let ret: PublishStorageDealsReturn = rt .call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() @@ -592,13 +587,11 @@ pub fn publish_deals_expect_abort( let client_signature = Signature::new_bls(deal_serialized.to_vec()); expect_query_network_info(rt); - let auth_param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: deal_serialized.to_vec(), - message: deal_serialized.to_vec(), - }) - .unwrap(), - ); + let auth_param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: deal_serialized.to_vec(), + message: deal_serialized.to_vec(), + }) + .unwrap(); rt.expect_send( proposal.client, @@ -617,7 +610,7 @@ pub fn publish_deals_expect_abort( expected_exit_code, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(&deal_params).unwrap()), + IpldBlock::serialize_cbor(&deal_params).unwrap(), ), ); @@ -771,13 +764,11 @@ where let buf = RawBytes::serialize(deal_proposal.clone()).expect("failed to marshal deal proposal"); let sig = Signature::new_bls(buf.to_vec()); - let auth_param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf.to_vec(), - message: buf.to_vec(), - }) - .unwrap(), - ); + let auth_param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf.to_vec(), + message: buf.to_vec(), + }) + .unwrap(); rt.expect_send( deal_proposal.client, @@ -799,7 +790,7 @@ where exit_code, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap_err() .exit_code() @@ -992,7 +983,7 @@ pub fn terminate_deals_raw( rt.call::( Method::OnMinerSectorsTerminate as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) } @@ -1029,7 +1020,7 @@ where let ret: VerifyDealsForActivationReturn = rt .call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), ) .unwrap() .deserialize() diff --git a/actors/market/tests/market_actor_test.rs b/actors/market/tests/market_actor_test.rs index 2e9ba8694..f36527928 100644 --- a/actors/market/tests/market_actor_test.rs +++ b/actors/market/tests/market_actor_test.rs @@ -199,7 +199,7 @@ fn adds_to_provider_escrow_funds() { RawBytes::default(), rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap()), + IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap(), ) .unwrap() ); @@ -236,7 +236,7 @@ fn fails_if_withdraw_from_non_provider_funds_is_not_initiated_by_the_recipient() ExitCode::USR_FORBIDDEN, rt.call::( Method::WithdrawBalance as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -376,7 +376,7 @@ fn fails_unless_called_by_an_account_actor() { ExitCode::USR_FORBIDDEN, rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap()), + IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap(), ) .unwrap_err() .exit_code() @@ -410,7 +410,7 @@ fn adds_to_non_provider_funds() { RawBytes::default(), rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(caller_addr).unwrap()), + IpldBlock::serialize_cbor(caller_addr).unwrap(), ) .unwrap() ); @@ -515,7 +515,7 @@ fn fail_when_balance_is_zero() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap()), + IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap(), ), ); @@ -536,7 +536,7 @@ fn fails_with_a_negative_withdraw_amount() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::WithdrawBalance as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -568,7 +568,7 @@ fn fails_if_withdraw_from_provider_funds_is_not_initiated_by_the_owner_or_worker ExitCode::USR_FORBIDDEN, rt.call::( Method::WithdrawBalance as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -822,7 +822,7 @@ fn provider_and_client_addresses_are_resolved_before_persisting_state_and_sent_t RawBytes::default(), rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&provider_bls).unwrap()), + IpldBlock::serialize_cbor(&provider_bls).unwrap(), ) .unwrap() ); @@ -845,13 +845,11 @@ fn provider_and_client_addresses_are_resolved_before_persisting_state_and_sent_t params.deals.push(client_proposal); // expect a call to verify the above signature - let auth_param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf.to_vec(), - message: buf.to_vec(), - }) - .unwrap(), - ); + let auth_param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf.to_vec(), + message: buf.to_vec(), + }) + .unwrap(); rt.expect_send( deal.client, @@ -898,7 +896,7 @@ fn provider_and_client_addresses_are_resolved_before_persisting_state_and_sent_t rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::TRANSFER_FROM_METHOD as u64, - Some(IpldBlock::serialize_cbor(&transfer_params).unwrap()), + IpldBlock::serialize_cbor(&transfer_params).unwrap(), TokenAmount::zero(), serialize(&transfer_return, "transfer from return").unwrap(), ExitCode::OK, @@ -907,7 +905,7 @@ fn provider_and_client_addresses_are_resolved_before_persisting_state_and_sent_t let ret: PublishStorageDealsReturn = rt .call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() @@ -1391,13 +1389,11 @@ fn cannot_publish_the_same_deal_twice_before_a_cron_tick() { expect_query_network_info(&mut rt); rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, WORKER_ADDR); - let auth_param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf.to_vec(), - message: buf.to_vec(), - }) - .unwrap(), - ); + let auth_param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf.to_vec(), + message: buf.to_vec(), + }) + .unwrap(); rt.expect_send( d2.client, @@ -1412,7 +1408,7 @@ fn cannot_publish_the_same_deal_twice_before_a_cron_tick() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -1442,7 +1438,7 @@ fn fail_when_current_epoch_greater_than_start_epoch_of_deal() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -1471,7 +1467,7 @@ fn fail_when_end_epoch_of_deal_greater_than_sector_expiry() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -1511,7 +1507,7 @@ fn fail_to_activate_all_deals_if_one_deal_fails() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -1772,7 +1768,7 @@ fn insufficient_client_balance_in_a_batch() { RawBytes::default(), rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap()), + IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap(), ) .unwrap() ); @@ -1801,20 +1797,16 @@ fn insufficient_client_balance_in_a_batch() { expect_provider_control_address(&mut rt, PROVIDER_ADDR, OWNER_ADDR, WORKER_ADDR); expect_query_network_info(&mut rt); - let authenticate_param1 = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf1.to_vec(), - message: buf1.to_vec(), - }) - .unwrap(), - ); - let authenticate_param2 = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf2.to_vec(), - message: buf2.to_vec(), - }) - .unwrap(), - ); + let authenticate_param1 = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf1.to_vec(), + message: buf1.to_vec(), + }) + .unwrap(); + let authenticate_param2 = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf2.to_vec(), + message: buf2.to_vec(), + }) + .unwrap(); rt.expect_send( deal1.client, @@ -1838,7 +1830,7 @@ fn insufficient_client_balance_in_a_batch() { let ret: PublishStorageDealsReturn = rt .call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() @@ -1889,7 +1881,7 @@ fn insufficient_provider_balance_in_a_batch() { RawBytes::default(), rt.call::( Method::AddBalance as u64, - Some(IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap()), + IpldBlock::serialize_cbor(&PROVIDER_ADDR).unwrap(), ) .unwrap() ); @@ -1922,20 +1914,16 @@ fn insufficient_provider_balance_in_a_batch() { expect_provider_control_address(&mut rt, PROVIDER_ADDR, OWNER_ADDR, WORKER_ADDR); expect_query_network_info(&mut rt); - let authenticate_param1 = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf1.to_vec(), - message: buf1.to_vec(), - }) - .unwrap(), - ); - let authenticate_param2 = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf2.to_vec(), - message: buf2.to_vec(), - }) - .unwrap(), - ); + let authenticate_param1 = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf1.to_vec(), + message: buf1.to_vec(), + }) + .unwrap(); + let authenticate_param2 = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf2.to_vec(), + message: buf2.to_vec(), + }) + .unwrap(); rt.expect_send( deal1.client, @@ -1959,7 +1947,7 @@ fn insufficient_provider_balance_in_a_batch() { let ret: PublishStorageDealsReturn = rt .call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() diff --git a/actors/market/tests/on_miner_sectors_terminate.rs b/actors/market/tests/on_miner_sectors_terminate.rs index 588965fd9..8650c3fd1 100644 --- a/actors/market/tests/on_miner_sectors_terminate.rs +++ b/actors/market/tests/on_miner_sectors_terminate.rs @@ -310,7 +310,7 @@ fn fail_when_caller_is_not_a_storage_miner_actor() { ExitCode::USR_FORBIDDEN, rt.call::( Method::OnMinerSectorsTerminate as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap_err() .exit_code() diff --git a/actors/market/tests/publish_storage_deals_failures.rs b/actors/market/tests/publish_storage_deals_failures.rs index a3d760748..b77daa50e 100644 --- a/actors/market/tests/publish_storage_deals_failures.rs +++ b/actors/market/tests/publish_storage_deals_failures.rs @@ -261,13 +261,11 @@ fn fail_when_provider_has_some_funds_but_not_enough_for_a_deal() { expect_query_network_info(&mut rt); rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, WORKER_ADDR); - let auth_param = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf.to_vec(), - message: buf.to_vec(), - }) - .unwrap(), - ); + let auth_param = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf.to_vec(), + message: buf.to_vec(), + }) + .unwrap(); rt.expect_send( deal1.client, @@ -282,7 +280,7 @@ fn fail_when_provider_has_some_funds_but_not_enough_for_a_deal() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -322,20 +320,16 @@ fn fail_when_deals_have_different_providers() { expect_provider_control_address(&mut rt, PROVIDER_ADDR, OWNER_ADDR, WORKER_ADDR); expect_query_network_info(&mut rt); rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, WORKER_ADDR); - let authenticate_param1 = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf1.to_vec(), - message: buf1.to_vec(), - }) - .unwrap(), - ); - let authenticate_param2 = Some( - IpldBlock::serialize_cbor(&AuthenticateMessageParams { - signature: buf2.to_vec(), - message: buf2.to_vec(), - }) - .unwrap(), - ); + let authenticate_param1 = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf1.to_vec(), + message: buf1.to_vec(), + }) + .unwrap(); + let authenticate_param2 = IpldBlock::serialize_cbor(&AuthenticateMessageParams { + signature: buf2.to_vec(), + message: buf2.to_vec(), + }) + .unwrap(); rt.expect_send( deal1.client, @@ -357,7 +351,7 @@ fn fail_when_deals_have_different_providers() { let psd_ret: PublishStorageDealsReturn = rt .call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap() .deserialize() @@ -388,7 +382,7 @@ fn fail_when_caller_is_not_of_signable_type() { ExitCode::USR_FORBIDDEN, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); check_state(&rt); @@ -404,7 +398,7 @@ fn fail_when_no_deals_in_params() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); check_state(&rt); @@ -429,7 +423,7 @@ fn fail_to_resolve_provider_address() { ExitCode::USR_NOT_FOUND, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); check_state(&rt); @@ -454,7 +448,7 @@ fn caller_is_not_the_same_as_the_worker_address_for_miner() { ExitCode::USR_FORBIDDEN, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -482,7 +476,7 @@ fn fails_if_provider_is_not_a_storage_miner_actor() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::PublishStorageDeals as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); diff --git a/actors/market/tests/verify_deals_for_activation_test.rs b/actors/market/tests/verify_deals_for_activation_test.rs index 42f0c4ad0..22d812786 100644 --- a/actors/market/tests/verify_deals_for_activation_test.rs +++ b/actors/market/tests/verify_deals_for_activation_test.rs @@ -179,7 +179,7 @@ fn fail_when_caller_is_not_a_storage_miner_actor() { ExitCode::USR_FORBIDDEN, rt.call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -204,7 +204,7 @@ fn fail_when_deal_proposal_is_not_found() { ExitCode::USR_NOT_FOUND, rt.call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -232,7 +232,7 @@ fn fail_when_caller_is_not_the_provider() { ExitCode::USR_FORBIDDEN, rt.call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -261,7 +261,7 @@ fn fail_when_current_epoch_is_greater_than_proposal_start_epoch() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -289,7 +289,7 @@ fn fail_when_deal_end_epoch_is_greater_than_sector_expiration() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -318,7 +318,7 @@ fn fail_when_the_same_deal_id_is_passed_multiple_times() { "multiple times", rt.call::( Method::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); diff --git a/actors/miner/src/lib.rs b/actors/miner/src/lib.rs index 294eb80e7..2eb31e0ea 100644 --- a/actors/miner/src/lib.rs +++ b/actors/miner/src/lib.rs @@ -1969,7 +1969,7 @@ impl Actor { rt.send( &STORAGE_POWER_ACTOR_ADDR, ext::power::SUBMIT_POREP_FOR_BULK_VERIFY_METHOD, - Some(IpldBlock::serialize_cbor(&svi)?), + IpldBlock::serialize_cbor(&svi)?, TokenAmount::zero(), )?; @@ -4022,10 +4022,8 @@ fn enroll_cron_event( cb: CronEventPayload, ) -> Result<(), ActorError> { let payload = serialize(&cb, "cron payload")?; - let ser_params = Some(IpldBlock::serialize_cbor(&ext::power::EnrollCronEventParams { - event_epoch, - payload, - })?); + let ser_params = + IpldBlock::serialize_cbor(&ext::power::EnrollCronEventParams { event_epoch, payload })?; rt.send( &STORAGE_POWER_ACTOR_ADDR, ext::power::ENROLL_CRON_EVENT_METHOD, @@ -4046,10 +4044,10 @@ fn request_update_power(rt: &mut impl Runtime, delta: PowerPair) -> Result<(), A rt.send( &STORAGE_POWER_ACTOR_ADDR, ext::power::UPDATE_CLAIMED_POWER_METHOD, - Some(IpldBlock::serialize_cbor(&ext::power::UpdateClaimedPowerParams { + IpldBlock::serialize_cbor(&ext::power::UpdateClaimedPowerParams { raw_byte_delta: delta.raw, quality_adjusted_delta: delta.qa, - })?), + })?, TokenAmount::zero(), ) .map_err(|e| e.wrap(format!("failed to update power with {:?}", delta_clone)))?; @@ -4068,10 +4066,10 @@ fn request_terminate_deals( rt.send( &STORAGE_MARKET_ACTOR_ADDR, ext::market::ON_MINER_SECTORS_TERMINATE_METHOD, - Some(IpldBlock::serialize_cbor(&ext::market::OnMinerSectorsTerminateParamsRef { + IpldBlock::serialize_cbor(&ext::market::OnMinerSectorsTerminateParamsRef { epoch, deal_ids: chunk, - })?), + })?, TokenAmount::zero(), )?; } @@ -4202,9 +4200,7 @@ fn request_deal_data( let serialized = rt.send( &STORAGE_MARKET_ACTOR_ADDR, ext::market::VERIFY_DEALS_FOR_ACTIVATION_METHOD, - Some(IpldBlock::serialize_cbor(&ext::market::VerifyDealsForActivationParamsRef { - sectors, - })?), + IpldBlock::serialize_cbor(&ext::market::VerifyDealsForActivationParamsRef { sectors })?, TokenAmount::zero(), )?; @@ -4327,7 +4323,7 @@ fn notify_pledge_changed( rt.send( &STORAGE_POWER_ACTOR_ADDR, ext::power::UPDATE_PLEDGE_TOTAL_METHOD, - Some(IpldBlock::serialize_cbor(pledge_delta)?), + IpldBlock::serialize_cbor(pledge_delta)?, TokenAmount::zero(), )?; } @@ -4345,7 +4341,7 @@ fn get_claims( let ret_raw = rt.send( &VERIFIED_REGISTRY_ACTOR_ADDR, ext::verifreg::GET_CLAIMS_METHOD as u64, - Some(IpldBlock::serialize_cbor(¶ms)?), + IpldBlock::serialize_cbor(¶ms)?, TokenAmount::zero(), )?; let claims_ret: ext::verifreg::GetClaimsReturn = deserialize(&ret_raw, "get claims return")?; @@ -4798,10 +4794,7 @@ fn activate_deals_and_claim_allocations( let activate_raw = rt.send( &STORAGE_MARKET_ACTOR_ADDR, ext::market::ACTIVATE_DEALS_METHOD, - Some(IpldBlock::serialize_cbor(&ext::market::ActivateDealsParams { - deal_ids, - sector_expiry, - })?), + IpldBlock::serialize_cbor(&ext::market::ActivateDealsParams { deal_ids, sector_expiry })?, TokenAmount::zero(), ); let activate_res: ext::market::ActivateDealsResult = match activate_raw { @@ -4835,10 +4828,10 @@ fn activate_deals_and_claim_allocations( let claim_raw = rt.send( &VERIFIED_REGISTRY_ACTOR_ADDR, ext::verifreg::CLAIM_ALLOCATIONS_METHOD, - Some(IpldBlock::serialize_cbor(&ext::verifreg::ClaimAllocationsParams { + IpldBlock::serialize_cbor(&ext::verifreg::ClaimAllocationsParams { sectors: sector_claims, all_or_nothing: true, - })?), + })?, TokenAmount::zero(), ); let claim_res: ext::verifreg::ClaimAllocationsReturn = match claim_raw { diff --git a/actors/miner/tests/apply_rewards.rs b/actors/miner/tests/apply_rewards.rs index 6438144c7..14a479ed0 100644 --- a/actors/miner/tests/apply_rewards.rs +++ b/actors/miner/tests/apply_rewards.rs @@ -144,11 +144,8 @@ fn penalty_is_partially_burnt_and_stored_as_fee_debt() { ); let params = ApplyRewardParams { reward, penalty }; - rt.call::( - Method::ApplyRewards as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) - .unwrap(); + rt.call::(Method::ApplyRewards as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) + .unwrap(); rt.verify(); let st = h.get_state(&rt); @@ -198,7 +195,7 @@ fn rewards_pay_back_fee_debt() { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&pledge_delta).unwrap()), + IpldBlock::serialize_cbor(&pledge_delta).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -215,11 +212,8 @@ fn rewards_pay_back_fee_debt() { ); let params = ApplyRewardParams { reward: reward.clone(), penalty }; - rt.call::( - Method::ApplyRewards as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) - .unwrap(); + rt.call::(Method::ApplyRewards as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) + .unwrap(); rt.verify(); // Set balance to deduct fee diff --git a/actors/miner/tests/change_worker_address_test.rs b/actors/miner/tests/change_worker_address_test.rs index 379627f72..59f23b3d7 100644 --- a/actors/miner/tests/change_worker_address_test.rs +++ b/actors/miner/tests/change_worker_address_test.rs @@ -244,7 +244,7 @@ fn fails_if_new_worker_address_does_not_have_a_code() { let params = ChangeWorkerAddressParams { new_worker, new_control_addresses: Vec::new() }; let result = rt.call::( Method::ChangeWorkerAddress as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort(ExitCode::USR_ILLEGAL_ARGUMENT, result); rt.verify(); @@ -263,7 +263,7 @@ fn fails_if_new_worker_is_not_account_actor() { let params = ChangeWorkerAddressParams { new_worker, new_control_addresses: Vec::new() }; let result = rt.call::( Method::ChangeWorkerAddress as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort(ExitCode::USR_ILLEGAL_ARGUMENT, result); rt.verify(); @@ -291,7 +291,7 @@ fn fails_when_caller_is_not_the_owner() { let params = ChangeWorkerAddressParams { new_worker, new_control_addresses: Vec::new() }; let result = rt.call::( Method::ChangeWorkerAddress as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort(ExitCode::USR_FORBIDDEN, result); rt.verify(); diff --git a/actors/miner/tests/miner_actor_test_construction.rs b/actors/miner/tests/miner_actor_test_construction.rs index 30cd4e021..d2301e8fc 100644 --- a/actors/miner/tests/miner_actor_test_construction.rs +++ b/actors/miner/tests/miner_actor_test_construction.rs @@ -81,10 +81,7 @@ fn simple_construction() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap(); assert_eq!(result.bytes().len(), 0); env.rt.verify(); @@ -157,10 +154,7 @@ fn control_addresses_are_resolved_during_construction() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap(); assert_eq!(result.bytes().len(), 0); env.rt.verify(); @@ -194,10 +188,7 @@ fn fails_if_control_address_is_not_an_account_actor() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); env.rt.verify(); @@ -213,10 +204,7 @@ fn test_construct_with_invalid_peer_id() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); env.rt.verify(); @@ -235,10 +223,7 @@ fn fails_if_control_addresses_exceeds_maximum_length() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); env.rt.verify(); @@ -257,10 +242,7 @@ fn test_construct_with_large_multiaddr() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); env.rt.verify(); @@ -278,10 +260,7 @@ fn test_construct_with_empty_multiaddr() { let result = env .rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); env.rt.verify(); diff --git a/actors/miner/tests/miner_actor_test_precommit_batch.rs b/actors/miner/tests/miner_actor_test_precommit_batch.rs index a44883cd0..e50b80af9 100644 --- a/actors/miner/tests/miner_actor_test_precommit_batch.rs +++ b/actors/miner/tests/miner_actor_test_precommit_batch.rs @@ -405,7 +405,7 @@ mod miner_actor_precommit_batch { rt.expect_send( STORAGE_MARKET_ACTOR_ADDR, MarketMethod::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(&vdparams).unwrap()), + IpldBlock::serialize_cbor(&vdparams).unwrap(), TokenAmount::zero(), RawBytes::serialize(vdreturn).unwrap(), ExitCode::OK, @@ -422,7 +422,7 @@ mod miner_actor_precommit_batch { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::EnrollCronEvent as u64, - Some(IpldBlock::serialize_cbor(&cron_params).unwrap()), + IpldBlock::serialize_cbor(&cron_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -430,7 +430,7 @@ mod miner_actor_precommit_batch { let result = rt.call::( Method::PreCommitSectorBatch2 as u64, - Some(IpldBlock::serialize_cbor(&PreCommitSectorBatchParams2 { sectors }).unwrap()), + IpldBlock::serialize_cbor(&PreCommitSectorBatchParams2 { sectors }).unwrap(), ); expect_abort_contains_message( diff --git a/actors/miner/tests/miner_actor_test_wpost.rs b/actors/miner/tests/miner_actor_test_wpost.rs index 008bc31b2..e57e77277 100644 --- a/actors/miner/tests/miner_actor_test_wpost.rs +++ b/actors/miner/tests/miner_actor_test_wpost.rs @@ -564,7 +564,7 @@ fn duplicate_proof_rejected() { let result = rt.call::( miner::Method::SubmitWindowedPoSt as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort_contains_message( ExitCode::USR_ILLEGAL_ARGUMENT, @@ -1040,7 +1040,7 @@ fn cannot_dispute_posts_when_the_challenge_window_is_open() { let result = rt.call::( miner::Method::DisputeWindowedPoSt as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort_contains_message( ExitCode::USR_FORBIDDEN, @@ -1102,7 +1102,7 @@ fn can_dispute_up_till_window_end_but_not_after() { let result = rt.call::( miner::Method::DisputeWindowedPoSt as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort_contains_message( ExitCode::USR_FORBIDDEN, @@ -1133,7 +1133,7 @@ fn cant_dispute_up_with_an_invalid_deadline() { let result = rt.call::( miner::Method::DisputeWindowedPoSt as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort_contains_message(ExitCode::USR_ILLEGAL_ARGUMENT, "invalid deadline", result); rt.verify(); diff --git a/actors/miner/tests/terminate_sectors_test.rs b/actors/miner/tests/terminate_sectors_test.rs index 22db25b62..90690c3dc 100644 --- a/actors/miner/tests/terminate_sectors_test.rs +++ b/actors/miner/tests/terminate_sectors_test.rs @@ -124,7 +124,7 @@ fn cannot_terminate_a_sector_when_the_challenge_window_is_open() { rt.expect_validate_caller_addr(h.caller_addrs()); let res = rt.call::( Method::TerminateSectors as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort_contains_message( ExitCode::USR_ILLEGAL_ARGUMENT, diff --git a/actors/miner/tests/util.rs b/actors/miner/tests/util.rs index 357759bf6..1f0ac29b4 100644 --- a/actors/miner/tests/util.rs +++ b/actors/miner/tests/util.rs @@ -267,10 +267,7 @@ impl ActorHarness { ); let result = rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap(); expect_empty(result); rt.verify(); @@ -287,10 +284,7 @@ impl ActorHarness { rt.expect_validate_caller_addr(caller_addrs); let result = rt - .call::( - Method::ChangePeerID as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::ChangePeerID as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap(); expect_empty(result); rt.verify(); @@ -307,10 +301,7 @@ impl ActorHarness { rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, self.worker); let result = rt - .call::( - Method::ChangePeerID as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::ChangePeerID as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); rt.verify(); @@ -325,7 +316,7 @@ impl ActorHarness { let result = rt .call::( Method::ChangeMultiaddrs as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap(); expect_empty(result); @@ -345,7 +336,7 @@ impl ActorHarness { let result = rt .call::( Method::ChangeMultiaddrs as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap_err(); assert_eq!(result.exit_code(), ExitCode::USR_ILLEGAL_ARGUMENT); @@ -488,7 +479,7 @@ impl ActorHarness { rt.call::( Method::CompactSectorNumbers as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) } @@ -673,7 +664,7 @@ impl ActorHarness { rt.expect_send( STORAGE_MARKET_ACTOR_ADDR, MarketMethod::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(&vdparams).unwrap()), + IpldBlock::serialize_cbor(&vdparams).unwrap(), TokenAmount::zero(), RawBytes::serialize(vdreturn).unwrap(), ExitCode::OK, @@ -706,15 +697,14 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::EnrollCronEvent as u64, - Some(IpldBlock::serialize_cbor(&cron_params).unwrap()), + IpldBlock::serialize_cbor(&cron_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, ); } - let result = - rt.call::(method as u64, Some(IpldBlock::serialize_cbor(¶m).unwrap())); + let result = rt.call::(method as u64, IpldBlock::serialize_cbor(¶m).unwrap()); result } @@ -757,7 +747,7 @@ impl ActorHarness { rt.expect_send( STORAGE_MARKET_ACTOR_ADDR, MarketMethod::VerifyDealsForActivation as u64, - Some(IpldBlock::serialize_cbor(&vdparams).unwrap()), + IpldBlock::serialize_cbor(&vdparams).unwrap(), TokenAmount::zero(), RawBytes::serialize(vdreturn).unwrap(), ExitCode::OK, @@ -787,7 +777,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::EnrollCronEvent as u64, - Some(IpldBlock::serialize_cbor(&cron_params).unwrap()), + IpldBlock::serialize_cbor(&cron_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -796,7 +786,7 @@ impl ActorHarness { let result = rt.call::( Method::PreCommitSector as u64, - Some(IpldBlock::serialize_cbor(¶ms.clone()).unwrap()), + IpldBlock::serialize_cbor(¶ms.clone()).unwrap(), ); result } @@ -912,7 +902,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::SubmitPoRepForBulkVerify as u64, - Some(IpldBlock::serialize_cbor(&seal).unwrap()), + IpldBlock::serialize_cbor(&seal).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -920,7 +910,7 @@ impl ActorHarness { rt.expect_validate_caller_any(); let result = rt.call::( Method::ProveCommitSector as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; expect_empty(result); rt.verify(); @@ -1003,7 +993,7 @@ impl ActorHarness { rt.expect_validate_caller_addr(addrs); rt.call::( MinerMethod::ProveCommitAggregate as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -1034,7 +1024,7 @@ impl ActorHarness { }; rt.call::( Method::ConfirmSectorProofsValid as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); Ok(()) @@ -1075,7 +1065,7 @@ impl ActorHarness { rt.expect_send( STORAGE_MARKET_ACTOR_ADDR, MarketMethod::ActivateDeals as u64, - Some(IpldBlock::serialize_cbor(&activate_params).unwrap()), + IpldBlock::serialize_cbor(&activate_params).unwrap(), TokenAmount::zero(), RawBytes::serialize(&ret).unwrap(), activate_deals_exit, @@ -1112,7 +1102,7 @@ impl ActorHarness { rt.expect_send( VERIFIED_REGISTRY_ACTOR_ADDR, CLAIM_ALLOCATIONS_METHOD as u64, - Some(IpldBlock::serialize_cbor(&claim_allocation_params).unwrap()), + IpldBlock::serialize_cbor(&claim_allocation_params).unwrap(), TokenAmount::zero(), RawBytes::serialize(&claim_allocs_ret).unwrap(), ExitCode::OK, @@ -1159,7 +1149,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&expected_pledge).unwrap()), + IpldBlock::serialize_cbor(&expected_pledge).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1231,7 +1221,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdateClaimedPower as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1273,7 +1263,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&pledge_delta).unwrap()), + IpldBlock::serialize_cbor(&pledge_delta).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1286,7 +1276,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::EnrollCronEvent as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1300,7 +1290,7 @@ impl ActorHarness { rt.set_caller(*POWER_ACTOR_CODE_ID, STORAGE_POWER_ACTOR_ADDR); rt.call::( Method::OnDeferredCronEvent as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap(); rt.verify(); @@ -1406,7 +1396,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdateClaimedPower as u64, - Some(IpldBlock::serialize_cbor(&claim).unwrap()), + IpldBlock::serialize_cbor(&claim).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1416,7 +1406,7 @@ impl ActorHarness { rt.call::( Method::SubmitWindowedPoSt as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) } @@ -1517,7 +1507,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdateClaimedPower as u64, - Some(IpldBlock::serialize_cbor(&claim).unwrap()), + IpldBlock::serialize_cbor(&claim).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1553,7 +1543,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&expected_pledge_delta).unwrap()), + IpldBlock::serialize_cbor(&expected_pledge_delta).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1565,7 +1555,7 @@ impl ActorHarness { DisputeWindowedPoStParams { deadline: deadline.index, post_index: proof_index }; let result = rt.call::( Method::DisputeWindowedPoSt as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); if expect_success.is_some() { @@ -1622,7 +1612,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&pledge_delta).unwrap()), + IpldBlock::serialize_cbor(&pledge_delta).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1640,11 +1630,8 @@ impl ActorHarness { } let params = ApplyRewardParams { reward: amt, penalty: penalty }; - rt.call::( - Method::ApplyRewards as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) - .unwrap(); + rt.call::(Method::ApplyRewards as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) + .unwrap(); rt.verify(); } @@ -1781,7 +1768,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdateClaimedPower as u64, - Some(IpldBlock::serialize_cbor(&claim).unwrap()), + IpldBlock::serialize_cbor(&claim).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1790,11 +1777,8 @@ impl ActorHarness { // Calculate params from faulted sector infos let state = self.get_state(rt); let params = make_fault_params_from_faulting_sectors(&rt, &state, fault_sector_infos); - rt.call::( - Method::DeclareFaults as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) - .unwrap(); + rt.call::(Method::DeclareFaults as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) + .unwrap(); rt.verify(); PowerPair { raw: expected_raw_delta, qa: expected_qa_delta } @@ -1828,7 +1812,7 @@ impl ActorHarness { let params = DeclareFaultsRecoveredParams { recoveries: vec![recovery] }; let ret = rt.call::( Method::DeclareFaultsRecovered as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); if ret.is_ok() { rt.verify(); @@ -1955,7 +1939,7 @@ impl ActorHarness { let result = rt.call::( Method::ReportConsensusFault as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; expect_empty(result); rt.verify(); @@ -2041,7 +2025,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, UPDATE_PLEDGE_TOTAL_METHOD, - Some(IpldBlock::serialize_cbor(&pledge_delta).unwrap()), + IpldBlock::serialize_cbor(&pledge_delta).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -2058,7 +2042,7 @@ impl ActorHarness { rt.expect_send( STORAGE_MARKET_ACTOR_ADDR, ON_MINER_SECTORS_TERMINATE_METHOD, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -2073,7 +2057,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, UPDATE_CLAIMED_POWER_METHOD, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -2099,7 +2083,7 @@ impl ActorHarness { rt.call::( Method::TerminateSectors as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap(); rt.verify(); @@ -2113,11 +2097,8 @@ impl ActorHarness { rt.expect_validate_caller_addr(self.caller_addrs()); rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, self.worker); - rt.call::( - Method::ChangePeerID as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) - .unwrap(); + rt.call::(Method::ChangePeerID as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) + .unwrap(); rt.verify(); let state: State = rt.get_state(); @@ -2143,7 +2124,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, PowerMethod::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&pledge_delta).unwrap()), + IpldBlock::serialize_cbor(&pledge_delta).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -2202,12 +2183,10 @@ impl ActorHarness { let ret = rt .call::( Method::WithdrawBalance as u64, - Some( - IpldBlock::serialize_cbor(&WithdrawBalanceParams { - amount_requested: amount_requested.clone(), - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&WithdrawBalanceParams { + amount_requested: amount_requested.clone(), + }) + .unwrap(), )? .deserialize::() .unwrap(); @@ -2232,7 +2211,7 @@ impl ActorHarness { rt.expect_validate_caller_any(); rt.call::( Method::CheckSectorProven as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); Ok(()) @@ -2263,7 +2242,7 @@ impl ActorHarness { rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, self.owner); let ret = rt.call::( Method::ChangeWorkerAddress as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); if ret.is_err() { @@ -2307,7 +2286,7 @@ impl ActorHarness { new_quota: beneficiary_term.quota, new_expiration: beneficiary_term.expiration, }; - let raw_bytes = Some(IpldBlock::serialize_cbor(¶m).unwrap()); + let raw_bytes = IpldBlock::serialize_cbor(¶m).unwrap(); rt.expect_validate_caller_any(); rt.call::(Method::ChangeBeneficiary as u64, raw_bytes.clone())?; rt.verify(); @@ -2342,7 +2321,7 @@ impl ActorHarness { rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, caller_id); let ret = rt.call::( Method::ChangeBeneficiary as u64, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), )?; rt.verify(); @@ -2410,7 +2389,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, UPDATE_CLAIMED_POWER_METHOD, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -2419,7 +2398,7 @@ impl ActorHarness { let ret = rt.call::( Method::ExtendSectorExpiration as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -2458,13 +2437,11 @@ impl ActorHarness { rt.expect_send( VERIFIED_REGISTRY_ACTOR_ADDR, fil_actor_miner::ext::verifreg::GET_CLAIMS_METHOD as u64, - Some( - IpldBlock::serialize_cbor(&GetClaimsParams { - provider: self.receiver.id().unwrap(), - claim_ids: all_claim_ids, - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&GetClaimsParams { + provider: self.receiver.id().unwrap(), + claim_ids: all_claim_ids, + }) + .unwrap(), TokenAmount::zero(), RawBytes::serialize(GetClaimsReturn { batch_info: batch_gen.gen(), claims }) .unwrap(), @@ -2511,7 +2488,7 @@ impl ActorHarness { rt.expect_send( STORAGE_POWER_ACTOR_ADDR, UPDATE_CLAIMED_POWER_METHOD, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -2520,7 +2497,7 @@ impl ActorHarness { let ret = rt.call::( Method::ExtendSectorExpiration2 as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); @@ -2540,7 +2517,7 @@ impl ActorHarness { rt.call::( Method::CompactPartitions as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; rt.verify(); Ok(()) @@ -2568,7 +2545,7 @@ impl ActorHarness { rt.expect_validate_caller_addr(vec![expected]); let ret = rt.call::( Method::ChangeOwnerAddress as u64, - Some(IpldBlock::serialize_cbor(&new_address).unwrap()), + IpldBlock::serialize_cbor(&new_address).unwrap(), ); if ret.is_ok() { diff --git a/actors/multisig/tests/multisig_actor_test.rs b/actors/multisig/tests/multisig_actor_test.rs index f215c6f87..a5f9278b4 100644 --- a/actors/multisig/tests/multisig_actor_test.rs +++ b/actors/multisig/tests/multisig_actor_test.rs @@ -62,7 +62,7 @@ mod constructor_tests { rt.set_caller(*INIT_ACTOR_CODE_ID, INIT_ACTOR_ADDR); let ret = rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); assert_eq!(RawBytes::default(), ret.unwrap()); rt.verify(); @@ -99,7 +99,7 @@ mod constructor_tests { let ret = rt .call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap(); assert_eq!(ret, RawBytes::default()); @@ -123,7 +123,7 @@ mod constructor_tests { RawBytes::default(), rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap() ) .unwrap() ); @@ -154,7 +154,7 @@ mod constructor_tests { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(&zero_signer_params).unwrap()), + IpldBlock::serialize_cbor(&zero_signer_params).unwrap(), ), ); rt.verify(); @@ -181,7 +181,7 @@ mod constructor_tests { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(&over_max_signers_params).unwrap()), + IpldBlock::serialize_cbor(&over_max_signers_params).unwrap(), ), ); rt.verify(); @@ -202,7 +202,7 @@ mod constructor_tests { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -233,7 +233,7 @@ mod constructor_tests { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -254,7 +254,7 @@ mod constructor_tests { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -277,7 +277,7 @@ mod constructor_tests { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -1567,7 +1567,7 @@ mod approval_tests { let params = TxnIDParams { id: TxnID(0), proposal_hash: Vec::::new() }; rt.call::( Method::Approve as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap(); rt.verify(); @@ -1632,7 +1632,7 @@ mod approval_tests { let params = TxnIDParams { id: dne_tx_id, proposal_hash: Vec::::new() }; rt.call::( Method::Approve as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .expect_err("should fail on approve of non existent tx id"); rt.verify(); @@ -2420,13 +2420,11 @@ fn token_receiver() { rt.expect_validate_caller_any(); let ret = rt.call::( Method::UniversalReceiverHook as MethodNum, - Some( - IpldBlock::serialize_cbor(&UniversalReceiverParams { - type_: 0, - payload: RawBytes::new(vec![1, 2, 3]), - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&UniversalReceiverParams { + type_: 0, + payload: RawBytes::new(vec![1, 2, 3]), + }) + .unwrap(), ); assert!(ret.is_ok()); assert_eq!(RawBytes::default(), ret.unwrap()); diff --git a/actors/multisig/tests/util.rs b/actors/multisig/tests/util.rs index ffd5ccab3..9fe1a625f 100644 --- a/actors/multisig/tests/util.rs +++ b/actors/multisig/tests/util.rs @@ -42,10 +42,7 @@ impl ActorHarness { rt.set_caller(*INIT_ACTOR_CODE_ID, INIT_ACTOR_ADDR); rt.expect_validate_caller_addr(vec![INIT_ACTOR_ADDR]); let result = rt - .call::( - Method::Constructor as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ) + .call::(Method::Constructor as u64, IpldBlock::serialize_cbor(¶ms).unwrap()) .unwrap(); assert_eq!(result.bytes().len(), 0); rt.verify(); @@ -59,10 +56,8 @@ impl ActorHarness { ) -> Result { rt.expect_validate_caller_addr(vec![rt.receiver]); let params = AddSignerParams { signer, increase }; - let ret = rt.call::( - Method::AddSigner as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ); + let ret = + rt.call::(Method::AddSigner as u64, IpldBlock::serialize_cbor(¶ms).unwrap()); rt.verify(); ret } @@ -77,7 +72,7 @@ impl ActorHarness { let params = RemoveSignerParams { signer, decrease }; let ret = rt.call::( Method::RemoveSigner as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); rt.verify(); ret @@ -91,10 +86,8 @@ impl ActorHarness { ) -> Result { rt.expect_validate_caller_addr(vec![rt.receiver]); let params = SwapSignerParams { from: old_signer, to: new_signer }; - let ret = rt.call::( - Method::SwapSigner as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), - ); + let ret = rt + .call::(Method::SwapSigner as u64, IpldBlock::serialize_cbor(¶ms).unwrap()); rt.verify(); ret } @@ -140,7 +133,7 @@ impl ActorHarness { let propose_params = ProposeParams { to, value, method, params }; let ret = rt.call::( Method::Propose as u64, - Some(IpldBlock::serialize_cbor(&propose_params).unwrap()), + IpldBlock::serialize_cbor(&propose_params).unwrap(), ); rt.verify(); ret @@ -157,7 +150,7 @@ impl ActorHarness { TxnIDParams { id: txn_id, proposal_hash: Vec::::from(proposal_hash) }; let ret = rt.call::( Method::Approve as u64, - Some(IpldBlock::serialize_cbor(&approve_params).unwrap()), + IpldBlock::serialize_cbor(&approve_params).unwrap(), ); rt.verify(); ret @@ -174,7 +167,7 @@ impl ActorHarness { TxnIDParams { id: txn_id, proposal_hash: Vec::::from(proposal_hash) }; let ret = rt.call::( Method::Cancel as u64, - Some(IpldBlock::serialize_cbor(&cancel_params).unwrap()), + IpldBlock::serialize_cbor(&cancel_params).unwrap(), ); rt.verify(); ret @@ -192,7 +185,7 @@ impl ActorHarness { LockBalanceParams { start_epoch: start, unlock_duration: duration, amount }; let ret = rt.call::( Method::LockBalance as u64, - Some(IpldBlock::serialize_cbor(&lock_balance_params).unwrap()), + IpldBlock::serialize_cbor(&lock_balance_params).unwrap(), ); rt.verify(); ret @@ -207,7 +200,7 @@ impl ActorHarness { let change_threshold_params = ChangeNumApprovalsThresholdParams { new_threshold }; let ret = rt.call::( Method::ChangeNumApprovalsThreshold as u64, - Some(IpldBlock::serialize_cbor(&change_threshold_params).unwrap()), + IpldBlock::serialize_cbor(&change_threshold_params).unwrap(), ); rt.verify(); ret diff --git a/actors/paych/tests/paych_actor_test.rs b/actors/paych/tests/paych_actor_test.rs index 013f603d3..556b0b006 100644 --- a/actors/paych/tests/paych_actor_test.rs +++ b/actors/paych/tests/paych_actor_test.rs @@ -117,7 +117,7 @@ mod paych_constructor { expect_abort( &mut rt, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ExitCode::USR_ILLEGAL_ARGUMENT, ); } @@ -193,7 +193,7 @@ mod paych_constructor { expect_abort( &mut rt, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), test_case.expected_exit_code, ); } @@ -232,7 +232,7 @@ mod paych_constructor { expect_abort( &mut rt, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ExitCode::USR_ILLEGAL_ARGUMENT, ); } @@ -269,7 +269,7 @@ mod paych_constructor { expect_abort( &mut rt, METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ExitCode::USR_ILLEGAL_ARGUMENT, ); } @@ -459,7 +459,7 @@ mod create_lane_tests { call( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&ucp).unwrap()), + IpldBlock::serialize_cbor(&ucp).unwrap(), ); let st: PState = rt.get_state(); @@ -474,7 +474,7 @@ mod create_lane_tests { expect_abort( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&ucp).unwrap()), + IpldBlock::serialize_cbor(&ucp).unwrap(), test_case.exp_exit_code, ); verify_initial_state(&rt, payer_addr, payee_addr); @@ -510,7 +510,7 @@ mod update_channel_state_redeem { call( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap(), ); rt.verify(); @@ -553,7 +553,7 @@ mod update_channel_state_redeem { call( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv.clone())).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv.clone())).unwrap(), ); rt.verify(); @@ -593,7 +593,7 @@ mod update_channel_state_redeem { expect_abort( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap(), ExitCode::USR_ILLEGAL_ARGUMENT, ); @@ -624,7 +624,7 @@ mod merge_tests { expect_abort( rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap(), exp_exit_code, ); rt.verify(); @@ -653,7 +653,7 @@ mod merge_tests { call( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv.clone())).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv.clone())).unwrap(), ); rt.verify(); let exp_merge_to = LaneState { redeemed: sv.amount.clone(), nonce: sv.nonce }; @@ -793,7 +793,7 @@ mod update_channel_state_extra { call( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap(), ); rt.verify(); check_state(&rt); @@ -805,7 +805,7 @@ mod update_channel_state_extra { expect_abort( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap(), ExitCode::USR_UNSPECIFIED, ); rt.verify(); @@ -857,11 +857,7 @@ fn update_channel_settling() { plaintext: ucp.sv.signing_bytes().unwrap(), result: Ok(()), }); - call( - &mut rt, - Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&ucp).unwrap()), - ); + call(&mut rt, Method::UpdateChannelState as u64, IpldBlock::serialize_cbor(&ucp).unwrap()); let new_state: PState = rt.get_state(); assert_eq!(tc.exp_settling_at, new_state.settling_at); assert_eq!(tc.exp_min_settle_height, new_state.min_settle_height); @@ -888,11 +884,7 @@ mod secret_preimage { result: Ok(()), }); - call( - &mut rt, - Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&ucp).unwrap()), - ); + call(&mut rt, Method::UpdateChannelState as u64, IpldBlock::serialize_cbor(&ucp).unwrap()); rt.verify(); check_state(&rt); @@ -919,7 +911,7 @@ mod secret_preimage { expect_abort( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&ucp).unwrap()), + IpldBlock::serialize_cbor(&ucp).unwrap(), ExitCode::USR_ILLEGAL_ARGUMENT, ); @@ -979,11 +971,7 @@ mod actor_settle { plaintext: sv.signing_bytes().unwrap(), result: Ok(()), }); - call( - &mut rt, - Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&ucp).unwrap()), - ); + call(&mut rt, Method::UpdateChannelState as u64, IpldBlock::serialize_cbor(&ucp).unwrap()); state = rt.get_state(); assert_eq!(state.settling_at, 0); @@ -1017,7 +1005,7 @@ mod actor_settle { expect_abort( &mut rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv)).unwrap(), ERR_CHANNEL_STATE_UPDATE_AFTER_SETTLED, ); } @@ -1193,7 +1181,7 @@ fn require_add_new_lane(rt: &mut MockRuntime, param: LaneParams) -> SignedVouche call( rt, Method::UpdateChannelState as u64, - Some(IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv.clone())).unwrap()), + IpldBlock::serialize_cbor(&UpdateChannelStateParams::from(sv.clone())).unwrap(), ); rt.verify(); sv.nonce += 1; @@ -1203,7 +1191,7 @@ fn require_add_new_lane(rt: &mut MockRuntime, param: LaneParams) -> SignedVouche fn construct_and_verify(rt: &mut MockRuntime, sender: Address, receiver: Address) { let params = ConstructorParams { from: sender, to: receiver }; rt.expect_validate_caller_type(vec![Type::Init]); - call(rt, METHOD_CONSTRUCTOR, Some(IpldBlock::serialize_cbor(¶ms).unwrap())); + call(rt, METHOD_CONSTRUCTOR, IpldBlock::serialize_cbor(¶ms).unwrap()); rt.verify(); let sender_id = rt.id_addresses.get(&sender).unwrap_or(&sender); let receiver_id = rt.id_addresses.get(&receiver).unwrap_or(&receiver); diff --git a/actors/power/src/lib.rs b/actors/power/src/lib.rs index 00b3bd371..0446062fd 100644 --- a/actors/power/src/lib.rs +++ b/actors/power/src/lib.rs @@ -102,10 +102,10 @@ impl Actor { .send( &INIT_ACTOR_ADDR, ext::init::EXEC_METHOD, - Some(IpldBlock::serialize_cbor(&init::ExecParams { + IpldBlock::serialize_cbor(&init::ExecParams { code_cid: miner_actor_code_cid, constructor_params, - })?), + })?, value, )? .deserialize()?; @@ -256,7 +256,7 @@ impl Actor { // Can assume delta is one since cron is invoked every epoch. st.update_smoothed_estimate(1); - Ok(Some(IpldBlock::serialize_cbor(&BigIntSer(&st.this_epoch_raw_byte_power))?)) + Ok(IpldBlock::serialize_cbor(&BigIntSer(&st.this_epoch_raw_byte_power))?) })?; // Update network KPA in reward actor @@ -484,15 +484,13 @@ impl Actor { if let Err(e) = rt.send( &m, ext::miner::CONFIRM_SECTOR_PROOFS_VALID_METHOD, - Some( - IpldBlock::serialize_cbor(&ext::miner::ConfirmSectorProofsParams { - sectors: successful, - reward_smoothed: rewret.this_epoch_reward_smoothed.clone(), - reward_baseline_power: rewret.this_epoch_baseline_power.clone(), - quality_adj_power_smoothed: this_epoch_qa_power_smoothed.clone(), - }) - .map_err(|e| format!("failed to serialize ConfirmSectorProofsParams: {}", e))?, - ), + IpldBlock::serialize_cbor(&ext::miner::ConfirmSectorProofsParams { + sectors: successful, + reward_smoothed: rewret.this_epoch_reward_smoothed.clone(), + reward_baseline_power: rewret.this_epoch_baseline_power.clone(), + quality_adj_power_smoothed: this_epoch_qa_power_smoothed.clone(), + }) + .map_err(|e| format!("failed to serialize ConfirmSectorProofsParams: {}", e))?, Default::default(), ) { error!("failed to confirm sector proof validity to {}, error code {}", m, e); @@ -569,11 +567,11 @@ impl Actor { let mut failed_miner_crons = Vec::new(); for event in cron_events { - let params = Some(IpldBlock::serialize_cbor(&ext::miner::DeferredCronEventParams { + let params = IpldBlock::serialize_cbor(&ext::miner::DeferredCronEventParams { event_payload: event.callback_payload.bytes().to_owned(), reward_smoothed: rewret.this_epoch_reward_smoothed.clone(), quality_adj_power_smoothed: st.this_epoch_qa_power_smoothed.clone(), - })?); + })?; let res = rt.send( &event.miner_addr, ext::miner::ON_DEFERRED_CRON_EVENT_METHOD, diff --git a/actors/power/tests/harness/mod.rs b/actors/power/tests/harness/mod.rs index 009fdd479..70fd7469b 100644 --- a/actors/power/tests/harness/mod.rs +++ b/actors/power/tests/harness/mod.rs @@ -160,7 +160,7 @@ impl Harness { rt.expect_send( INIT_ACTOR_ADDR, ext::init::EXEC_METHOD, - Some(IpldBlock::serialize_cbor(&expected_init_params).unwrap()), + IpldBlock::serialize_cbor(&expected_init_params).unwrap(), value.clone(), RawBytes::serialize(create_miner_ret).unwrap(), ExitCode::OK, @@ -174,7 +174,7 @@ impl Harness { }; rt.call::( Method::CreateMiner as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; Ok(()) } @@ -248,13 +248,11 @@ impl Harness { ) -> Result<(), ActorError> { rt.set_caller(*MINER_ACTOR_CODE_ID, miner_address.to_owned()); rt.expect_validate_caller_type(vec![Type::Miner]); - let params = Some( - IpldBlock::serialize_cbor(&EnrollCronEventParams { - event_epoch: epoch, - payload: payload.clone(), - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&EnrollCronEventParams { + event_epoch: epoch, + payload: payload.clone(), + }) + .unwrap(); rt.call::(Method::EnrollCronEvent as u64, params)?; rt.verify(); Ok(()) @@ -294,7 +292,7 @@ impl Harness { rt.expect_validate_caller_type(vec![Type::Miner]); rt.call::( Method::UpdatePledgeTotal as MethodNum, - Some(IpldBlock::serialize_cbor(&delta).unwrap()), + IpldBlock::serialize_cbor(&delta).unwrap(), ) .unwrap(); rt.verify(); @@ -331,7 +329,7 @@ impl Harness { rt.expect_validate_caller_type(vec![Type::Miner]); rt.call::( Method::UpdateClaimedPower as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ) .unwrap(); rt.verify(); @@ -414,7 +412,7 @@ impl Harness { rt.expect_send( sector.miner, CONFIRM_SECTOR_PROOFS_VALID_METHOD, - Some(IpldBlock::serialize_cbor(¶m).unwrap()), + IpldBlock::serialize_cbor(¶m).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::new(0), @@ -428,7 +426,7 @@ impl Harness { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(expected_raw_power)).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(expected_raw_power)).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::new(0), @@ -459,7 +457,7 @@ impl Harness { rt.set_caller(*MINER_ACTOR_CODE_ID, miner_address); rt.call::( Method::SubmitPoRepForBulkVerify as u64, - Some(IpldBlock::serialize_cbor(&seal_info).unwrap()), + IpldBlock::serialize_cbor(&seal_info).unwrap(), )?; rt.verify(); Ok(()) diff --git a/actors/power/tests/power_actor_tests.rs b/actors/power/tests/power_actor_tests.rs index 8be445495..e7a94f33a 100644 --- a/actors/power/tests/power_actor_tests.rs +++ b/actors/power/tests/power_actor_tests.rs @@ -97,7 +97,7 @@ fn create_miner_given_caller_is_not_of_signable_type_should_fail() { ExitCode::USR_FORBIDDEN, rt.call::( Method::CreateMiner as u64, - Some(IpldBlock::serialize_cbor(&&create_miner_params).unwrap()), + IpldBlock::serialize_cbor(&&create_miner_params).unwrap(), ), ); rt.verify(); @@ -141,7 +141,7 @@ fn create_miner_given_send_to_init_actor_fails_should_fail() { rt.expect_send( INIT_ACTOR_ADDR, EXEC_METHOD, - Some(IpldBlock::serialize_cbor(&message_params).unwrap()), + IpldBlock::serialize_cbor(&message_params).unwrap(), TokenAmount::from_atto(10), RawBytes::default(), ExitCode::SYS_INSUFFICIENT_FUNDS, @@ -151,7 +151,7 @@ fn create_miner_given_send_to_init_actor_fails_should_fail() { ExitCode::SYS_INSUFFICIENT_FUNDS, rt.call::( Method::CreateMiner as u64, - Some(IpldBlock::serialize_cbor(&create_miner_params).unwrap()), + IpldBlock::serialize_cbor(&create_miner_params).unwrap(), ), ); rt.verify(); @@ -174,7 +174,7 @@ fn claimed_power_given_caller_is_not_storage_miner_should_fail() { ExitCode::USR_FORBIDDEN, rt.call::( Method::UpdateClaimedPower as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -198,7 +198,7 @@ fn claimed_power_given_claim_does_not_exist_should_fail() { ExitCode::USR_NOT_FOUND, rt.call::( Method::UpdateClaimedPower as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -459,7 +459,7 @@ fn enroll_cron_epoch_given_negative_epoch_should_fail() { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::EnrollCronEvent as u64, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); @@ -606,7 +606,7 @@ fn given_no_miner_claim_update_pledge_total_should_abort() { "unknown miner", rt.call::( Method::UpdatePledgeTotal as u64, - Some(IpldBlock::serialize_cbor(&&TokenAmount::from_atto(1_000_000)).unwrap()), + IpldBlock::serialize_cbor(&&TokenAmount::from_atto(1_000_000)).unwrap(), ), ); @@ -641,7 +641,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, RewardMethod::UpdateNetworkKPI as u64, - Some(IpldBlock::serialize_cbor(&BigIntSer(&expected_power)).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&expected_power)).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -729,7 +729,7 @@ mod cron_tests { rt.expect_send( miner1, ON_DEFERRED_CRON_EVENT_METHOD, - Some(IpldBlock::serialize_cbor(¶ms1).unwrap()), + IpldBlock::serialize_cbor(¶ms1).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -743,7 +743,7 @@ mod cron_tests { rt.expect_send( miner2, ON_DEFERRED_CRON_EVENT_METHOD, - Some(IpldBlock::serialize_cbor(¶ms2).unwrap()), + IpldBlock::serialize_cbor(¶ms2).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -752,7 +752,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&expected_raw_byte_power)).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&expected_raw_byte_power)).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -780,7 +780,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&expected_raw_byte_power)).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&expected_raw_byte_power)).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -811,7 +811,7 @@ mod cron_tests { rt.expect_send( miner_addr, ON_DEFERRED_CRON_EVENT_METHOD, - Some(IpldBlock::serialize_cbor(&input).unwrap()), + IpldBlock::serialize_cbor(&input).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -819,7 +819,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&expected_raw_byte_power)).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&expected_raw_byte_power)).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -886,7 +886,7 @@ mod cron_tests { rt.expect_send( miner2, ON_DEFERRED_CRON_EVENT_METHOD, - Some(IpldBlock::serialize_cbor(&input).unwrap()), + IpldBlock::serialize_cbor(&input).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -896,7 +896,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -942,14 +942,12 @@ mod cron_tests { h.expect_query_network_info(&mut rt); let state: State = rt.get_state(); - let input = Some( - IpldBlock::serialize_cbor(&DeferredCronEventParams { - event_payload: Vec::new(), - reward_smoothed: h.this_epoch_reward_smoothed.clone(), - quality_adj_power_smoothed: state.this_epoch_qa_power_smoothed, - }) - .unwrap(), - ); + let input = IpldBlock::serialize_cbor(&DeferredCronEventParams { + event_payload: Vec::new(), + reward_smoothed: h.this_epoch_reward_smoothed.clone(), + quality_adj_power_smoothed: state.this_epoch_qa_power_smoothed, + }) + .unwrap(); // first send fails rt.expect_send( @@ -975,7 +973,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1002,7 +1000,7 @@ mod cron_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1236,7 +1234,7 @@ mod cron_batch_proof_verifies_tests { rt.expect_send( cs.miner, CONFIRM_SECTOR_PROOFS_VALID_METHOD, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1248,7 +1246,7 @@ mod cron_batch_proof_verifies_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -1284,7 +1282,7 @@ mod cron_batch_proof_verifies_tests { rt.expect_send( REWARD_ACTOR_ADDR, UPDATE_NETWORK_KPI, - Some(IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap()), + IpldBlock::serialize_cbor(&BigIntSer(&BigInt::zero())).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, diff --git a/actors/reward/src/lib.rs b/actors/reward/src/lib.rs index af64c94c4..885214eed 100644 --- a/actors/reward/src/lib.rs +++ b/actors/reward/src/lib.rs @@ -150,7 +150,7 @@ impl Actor { let res = rt.send( &Address::new_id(miner_id), ext::miner::APPLY_REWARDS_METHOD, - Some(IpldBlock::serialize_cbor(&reward_params)?), + IpldBlock::serialize_cbor(&reward_params)?, total_reward.clone(), ); if let Err(e) = res { diff --git a/actors/reward/tests/reward_actor_test.rs b/actors/reward/tests/reward_actor_test.rs index 1bf642af4..384b0ef28 100644 --- a/actors/reward/tests/reward_actor_test.rs +++ b/actors/reward/tests/reward_actor_test.rs @@ -93,15 +93,13 @@ mod test_award_block_reward { rt.set_balance(TokenAmount::from_atto(9)); rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); - let params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner: *WINNER, - penalty: TokenAmount::zero(), - gas_reward: TokenAmount::from_atto(10), - win_count: 1, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner: *WINNER, + penalty: TokenAmount::zero(), + gas_reward: TokenAmount::from_atto(10), + win_count: 1, + }) + .unwrap(); let result = rt.call::(Method::AwardBlockReward as u64, params); expect_abort(ExitCode::USR_ILLEGAL_STATE, result); @@ -117,15 +115,13 @@ mod test_award_block_reward { for (reward, penalty) in &reward_penalty_pairs { rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); - let params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner: *WINNER, - penalty: TokenAmount::from_atto(*penalty), - gas_reward: TokenAmount::from_atto(*reward), - win_count: 1, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner: *WINNER, + penalty: TokenAmount::from_atto(*penalty), + gas_reward: TokenAmount::from_atto(*reward), + win_count: 1, + }) + .unwrap(); let result = rt.call::(Method::AwardBlockReward as u64, params); expect_abort(ExitCode::USR_ILLEGAL_ARGUMENT, result); @@ -140,15 +136,13 @@ mod test_award_block_reward { rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); - let params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner: *WINNER, - penalty: TokenAmount::zero(), - gas_reward: TokenAmount::zero(), - win_count: 0, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner: *WINNER, + penalty: TokenAmount::zero(), + gas_reward: TokenAmount::zero(), + win_count: 0, + }) + .unwrap(); let result = rt.call::(Method::AwardBlockReward as u64, params); assert!(result.is_err()); @@ -164,13 +158,11 @@ mod test_award_block_reward { let expected_reward: TokenAmount = EPOCH_ZERO_REWARD.div_floor(EXPECTED_LEADERS_PER_EPOCH) + &gas_reward; let miner_penalty = PENALTY_MULTIPLIER * &penalty; - let params = Some( - IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { - reward: expected_reward.clone(), - penalty: miner_penalty, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { + reward: expected_reward.clone(), + penalty: miner_penalty, + }) + .unwrap(); rt.expect_send( *WINNER, ext::miner::APPLY_REWARDS_METHOD, @@ -179,15 +171,13 @@ mod test_award_block_reward { RawBytes::default(), ExitCode::OK, ); - let inner_params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner: *WINNER, - penalty, - gas_reward, - win_count: 1, - }) - .unwrap(), - ); + let inner_params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner: *WINNER, + penalty, + gas_reward, + win_count: 1, + }) + .unwrap(); assert!(rt.call::(Method::AwardBlockReward as u64, inner_params).is_ok()); rt.verify(); rt.reset(); @@ -204,13 +194,11 @@ mod test_award_block_reward { rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); let miner_penalty = PENALTY_MULTIPLIER * &penalty; - let params = Some( - IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { - reward: small_reward.clone(), - penalty: miner_penalty, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { + reward: small_reward.clone(), + penalty: miner_penalty, + }) + .unwrap(); rt.expect_send( *WINNER, ext::miner::APPLY_REWARDS_METHOD, @@ -220,15 +208,13 @@ mod test_award_block_reward { ExitCode::OK, ); - let inner_params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner: *WINNER, - penalty, - gas_reward: TokenAmount::zero(), - win_count: 1, - }) - .unwrap(), - ); + let inner_params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner: *WINNER, + penalty, + gas_reward: TokenAmount::zero(), + win_count: 1, + }) + .unwrap(); assert!(rt.call::(Method::AwardBlockReward as u64, inner_params).is_ok()); rt.verify(); } @@ -276,13 +262,11 @@ mod test_award_block_reward { rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]); let expected_reward = TokenAmount::from_atto(1000); let miner_penalty = TokenAmount::zero(); - let params = Some( - IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { - reward: expected_reward.clone(), - penalty: miner_penalty, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { + reward: expected_reward.clone(), + penalty: miner_penalty, + }) + .unwrap(); rt.expect_send( *WINNER, ext::miner::APPLY_REWARDS_METHOD, @@ -300,15 +284,13 @@ mod test_award_block_reward { ExitCode::OK, ); - let inner_params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner: *WINNER, - penalty: TokenAmount::zero(), - gas_reward: TokenAmount::zero(), - win_count: 1, - }) - .unwrap(), - ); + let inner_params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner: *WINNER, + penalty: TokenAmount::zero(), + gas_reward: TokenAmount::zero(), + win_count: 1, + }) + .unwrap(); assert!(rt.call::(Method::AwardBlockReward as u64, inner_params).is_ok()); @@ -354,7 +336,7 @@ fn construct_and_verify(curr_power: &StoragePower) -> MockRuntime { let ret = rt .call::( METHOD_CONSTRUCTOR, - Some(IpldBlock::serialize_cbor(&(BigIntSer(curr_power))).unwrap()), + IpldBlock::serialize_cbor(&(BigIntSer(curr_power))).unwrap(), ) .unwrap(); @@ -376,13 +358,11 @@ fn award_block_reward( rt.expect_send( miner, ext::miner::APPLY_REWARDS_METHOD, - Some( - IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { - reward: expected_payment.clone(), - penalty: miner_penalty, - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&ext::miner::ApplyRewardParams { + reward: expected_payment.clone(), + penalty: miner_penalty, + }) + .unwrap(), expected_payment.clone(), RawBytes::default(), ExitCode::OK, @@ -399,15 +379,13 @@ fn award_block_reward( ); } - let params = Some( - IpldBlock::serialize_cbor(&AwardBlockRewardParams { - miner, - penalty, - gas_reward, - win_count, - }) - .unwrap(), - ); + let params = IpldBlock::serialize_cbor(&AwardBlockRewardParams { + miner, + penalty, + gas_reward, + win_count, + }) + .unwrap(); let serialized_bytes = rt.call::(Method::AwardBlockReward as u64, params)?; @@ -427,7 +405,7 @@ fn update_network_kpi(rt: &mut MockRuntime, curr_raw_power: &StoragePower) { rt.set_caller(*POWER_ACTOR_CODE_ID, STORAGE_POWER_ACTOR_ADDR); rt.expect_validate_caller_addr(vec![STORAGE_POWER_ACTOR_ADDR]); - let params = Some(IpldBlock::serialize_cbor(&(BigIntSer(curr_raw_power))).unwrap()); + let params = IpldBlock::serialize_cbor(&(BigIntSer(curr_raw_power))).unwrap(); assert!(rt.call::(Method::UpdateNetworkKPI as u64, params).is_ok()); rt.verify(); } diff --git a/actors/verifreg/src/lib.rs b/actors/verifreg/src/lib.rs index 2b4ad1120..c20eece81 100644 --- a/actors/verifreg/src/lib.rs +++ b/actors/verifreg/src/lib.rs @@ -715,7 +715,7 @@ fn is_verifier(rt: &impl Runtime, st: &State, address: Address) -> Result Result { - let params = Some(IpldBlock::serialize_cbor(owner)?); + let params = IpldBlock::serialize_cbor(owner)?; let ret = rt .send( &DATACAP_TOKEN_ACTOR_ADDR, @@ -740,7 +740,7 @@ fn mint( rt.send( &DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Mint as u64, - Some(IpldBlock::serialize_cbor(¶ms)?), + IpldBlock::serialize_cbor(¶ms)?, TokenAmount::zero(), ) .context(format!("failed to send mint {:?} to datacap", params))?; @@ -758,7 +758,7 @@ fn burn(rt: &mut impl Runtime, amount: &DataCap) -> Result<(), ActorError> { rt.send( &DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Burn as u64, - Some(IpldBlock::serialize_cbor(¶ms)?), + IpldBlock::serialize_cbor(¶ms)?, TokenAmount::zero(), ) .context(format!("failed to send burn {:?} to datacap", params))?; @@ -777,7 +777,7 @@ fn destroy(rt: &mut impl Runtime, owner: &Address, amount: &DataCap) -> Result<( rt.send( &DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Destroy as u64, - Some(IpldBlock::serialize_cbor(¶ms)?), + IpldBlock::serialize_cbor(¶ms)?, TokenAmount::zero(), ) .context(format!("failed to send destroy {:?} to datacap", params))?; @@ -795,7 +795,7 @@ fn transfer(rt: &mut impl Runtime, to: ActorID, amount: &DataCap) -> Result<(), rt.send( &DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Transfer as u64, - Some(IpldBlock::serialize_cbor(¶ms)?), + IpldBlock::serialize_cbor(¶ms)?, TokenAmount::zero(), ) .context(format!("failed to send transfer to datacap {:?}", params))?; diff --git a/actors/verifreg/tests/harness/mod.rs b/actors/verifreg/tests/harness/mod.rs index 99a33975e..09faf88f3 100644 --- a/actors/verifreg/tests/harness/mod.rs +++ b/actors/verifreg/tests/harness/mod.rs @@ -68,7 +68,7 @@ impl Harness { let ret = rt .call::( Method::Constructor as MethodNum, - Some(IpldBlock::serialize_cbor(root_param).unwrap()), + IpldBlock::serialize_cbor(root_param).unwrap(), ) .unwrap(); @@ -104,7 +104,7 @@ impl Harness { rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::BalanceOf as MethodNum, - Some(IpldBlock::serialize_cbor(&verifier_resolved).unwrap()), + IpldBlock::serialize_cbor(&verifier_resolved).unwrap(), TokenAmount::zero(), serialize(&BigIntSer(&(cap * TOKEN_PRECISION)), "").unwrap(), ExitCode::OK, @@ -113,7 +113,7 @@ impl Harness { let params = AddVerifierParams { address: *verifier, allowance: allowance.clone() }; let ret = rt.call::( Method::AddVerifier as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; assert_eq!(RawBytes::default(), ret); rt.verify(); @@ -131,7 +131,7 @@ impl Harness { rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, self.root); let ret = rt.call::( Method::RemoveVerifier as MethodNum, - Some(IpldBlock::serialize_cbor(verifier).unwrap()), + IpldBlock::serialize_cbor(verifier).unwrap(), )?; assert_eq!(RawBytes::default(), ret); rt.verify(); @@ -182,7 +182,7 @@ impl Harness { rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Mint as MethodNum, - Some(IpldBlock::serialize_cbor(&mint_params).unwrap()), + IpldBlock::serialize_cbor(&mint_params).unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -191,7 +191,7 @@ impl Harness { let params = AddVerifierClientParams { address: *client, allowance: allowance.clone() }; let ret = rt.call::( Method::AddVerifiedClient as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; assert_eq!(RawBytes::default(), ret); rt.verify(); @@ -249,12 +249,10 @@ impl Harness { rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Burn as MethodNum, - Some( - IpldBlock::serialize_cbor(&BurnParams { - amount: TokenAmount::from_whole(datacap_burnt.to_i64().unwrap()), - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&BurnParams { + amount: TokenAmount::from_whole(datacap_burnt.to_i64().unwrap()), + }) + .unwrap(), TokenAmount::zero(), RawBytes::serialize(&BurnReturn { balance: TokenAmount::zero() }).unwrap(), ExitCode::OK, @@ -265,7 +263,7 @@ impl Harness { let ret = rt .call::( Method::ClaimAllocations as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )? .deserialize() .expect("failed to deserialize claim allocations return"); @@ -286,14 +284,12 @@ impl Harness { rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Transfer as MethodNum, - Some( - IpldBlock::serialize_cbor(&TransferParams { - to: Address::new_id(client), - amount: TokenAmount::from_whole(expected_datacap.to_i64().unwrap()), - operator_data: RawBytes::default(), - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&TransferParams { + to: Address::new_id(client), + amount: TokenAmount::from_whole(expected_datacap.to_i64().unwrap()), + operator_data: RawBytes::default(), + }) + .unwrap(), TokenAmount::zero(), RawBytes::default(), ExitCode::OK, @@ -303,7 +299,7 @@ impl Harness { let ret = rt .call::( Method::RemoveExpiredAllocations as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )? .deserialize() .expect("failed to deserialize remove expired allocations return"); @@ -324,7 +320,7 @@ impl Harness { let ret = rt .call::( Method::RemoveExpiredClaims as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )? .deserialize() .expect("failed to deserialize remove expired claims return"); @@ -362,12 +358,10 @@ impl Harness { rt.expect_send( DATACAP_TOKEN_ACTOR_ADDR, ext::datacap::Method::Burn as MethodNum, - Some( - IpldBlock::serialize_cbor(&BurnParams { - amount: TokenAmount::from_whole(expected_burn), - }) - .unwrap(), - ), + IpldBlock::serialize_cbor(&BurnParams { + amount: TokenAmount::from_whole(expected_burn), + }) + .unwrap(), TokenAmount::zero(), RawBytes::serialize(&BurnReturn { balance: TokenAmount::zero() }).unwrap(), ExitCode::OK, @@ -377,7 +371,7 @@ impl Harness { rt.expect_validate_caller_addr(vec![DATACAP_TOKEN_ACTOR_ADDR]); let ret = rt.call::( Method::UniversalReceiverHook as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )?; assert_eq!( RawBytes::serialize(AllocationsResponse { @@ -417,7 +411,7 @@ impl Harness { let ret = rt .call::( Method::GetClaims as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )? .deserialize() .expect("failed to deserialize get claims return"); @@ -434,7 +428,7 @@ impl Harness { let ret = rt .call::( Method::ExtendClaimTerms as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), )? .deserialize() .expect("failed to deserialize extend claim terms return"); diff --git a/actors/verifreg/tests/verifreg_actor_test.rs b/actors/verifreg/tests/verifreg_actor_test.rs index 1a0973e60..9b0cfc5ca 100644 --- a/actors/verifreg/tests/verifreg_actor_test.rs +++ b/actors/verifreg/tests/verifreg_actor_test.rs @@ -69,7 +69,7 @@ mod construction { ExitCode::USR_ILLEGAL_ARGUMENT, rt.call::( Method::Constructor as MethodNum, - Some(IpldBlock::serialize_cbor(&root_pubkey).unwrap()), + IpldBlock::serialize_cbor(&root_pubkey).unwrap(), ), ); } @@ -102,7 +102,7 @@ mod verifiers { ExitCode::USR_FORBIDDEN, rt.call::( Method::AddVerifier as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); h.check_state(&rt); @@ -116,7 +116,7 @@ mod verifiers { let params = AddVerifierParams { address: *VERIFIER, allowance }; let result = rt.call::( Method::AddVerifier as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort(ExitCode::USR_ILLEGAL_ARGUMENT, result); h.check_state(&rt); @@ -164,7 +164,7 @@ mod verifiers { let params = AddVerifierParams { address: verifier_key_address, allowance }; let result = rt.call::( Method::AddVerifier as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ); expect_abort(ExitCode::USR_ILLEGAL_ARGUMENT, result); @@ -203,7 +203,7 @@ mod verifiers { ExitCode::USR_FORBIDDEN, rt.call::( Method::RemoveVerifier as MethodNum, - Some(IpldBlock::serialize_cbor(VERIFIER.deref()).unwrap()), + IpldBlock::serialize_cbor(VERIFIER.deref()).unwrap(), ), ); h.check_state(&rt); @@ -380,7 +380,7 @@ mod clients { ExitCode::USR_NOT_FOUND, rt.call::( Method::AddVerifiedClient as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); h.check_state(&rt); @@ -1080,7 +1080,7 @@ mod datacap { "caller address", rt.call::( Method::UniversalReceiverHook as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); @@ -1112,7 +1112,7 @@ mod datacap { "token receiver expected to", rt.call::( Method::UniversalReceiverHook as MethodNum, - Some(IpldBlock::serialize_cbor(¶ms).unwrap()), + IpldBlock::serialize_cbor(¶ms).unwrap(), ), ); rt.verify(); diff --git a/runtime/src/dispatch.rs b/runtime/src/dispatch.rs index 4ac7d81f8..b4e621b31 100644 --- a/runtime/src/dispatch.rs +++ b/runtime/src/dispatch.rs @@ -156,10 +156,8 @@ fn test_dispatch() { } let mut rt = MockRuntime; - let arg = Some( - IpldBlock::serialize_cbor(&SomeArgs { foo: "foo".into() }) - .expect("failed to serialize arguments"), - ); + let arg = IpldBlock::serialize_cbor(&SomeArgs { foo: "foo".into() }) + .expect("failed to serialize arguments"); // Correct dispatch assert!(dispatch(&mut rt, with_arg, &arg).expect("failed to dispatch").is_empty()); diff --git a/test_vm/src/lib.rs b/test_vm/src/lib.rs index 450dec514..cedb7370a 100644 --- a/test_vm/src/lib.rs +++ b/test_vm/src/lib.rs @@ -420,7 +420,7 @@ impl<'bs> VM<'bs> { to, value, method, - params: params.map(|p| IpldBlock::serialize_cbor(&p).unwrap()), + params: params.map(|p| IpldBlock::serialize_cbor(&p).unwrap().unwrap()), }; let mut new_ctx = InvocationCtx { v: self, @@ -592,7 +592,7 @@ impl<'invocation, 'bs> InvocationCtx<'invocation, 'bs> { to: target_id_addr, value: TokenAmount::zero(), method: METHOD_CONSTRUCTOR, - params: Some(IpldBlock::serialize_cbor(target).unwrap()), + params: IpldBlock::serialize_cbor(target).unwrap(), }; { let mut new_ctx = InvocationCtx { diff --git a/test_vm/src/util.rs b/test_vm/src/util.rs index d8656d040..0f4b3a9c9 100644 --- a/test_vm/src/util.rs +++ b/test_vm/src/util.rs @@ -311,12 +311,12 @@ pub fn precommit_sectors_v2( let expect = ExpectInvocation { to: mid, method: MinerMethod::PreCommitSectorBatch as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&PreCommitSectorBatchParams { sectors: param_sectors, }) .unwrap(), - )), + ), subinvocs: Some(invocs), ..Default::default() }; @@ -359,12 +359,12 @@ pub fn precommit_sectors_v2( let expect = ExpectInvocation { to: mid, method: MinerMethod::PreCommitSectorBatch2 as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&PreCommitSectorBatchParams2 { sectors: param_sectors, }) .unwrap(), - )), + ), subinvocs: Some(invocs), ..Default::default() }; @@ -423,7 +423,7 @@ pub fn prove_commit_sectors( aggregate_proof: vec![], }; let prove_commit_aggregate_params_ser = - Some(IpldBlock::serialize_cbor(&prove_commit_aggregate_params).unwrap()); + IpldBlock::serialize_cbor(&prove_commit_aggregate_params).unwrap(); apply_ok( v, @@ -510,13 +510,13 @@ pub fn miner_extend_sector_expiration2( to: VERIFIED_REGISTRY_ACTOR_ADDR, method: VerifregMethod::GetClaims as u64, code: Some(ExitCode::OK), - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&GetClaimsParams { provider: miner_id.id().unwrap(), claim_ids, }) .unwrap(), - )), + ), ..Default::default() }) } @@ -524,13 +524,13 @@ pub fn miner_extend_sector_expiration2( subinvocs.push(ExpectInvocation { to: STORAGE_POWER_ACTOR_ADDR, method: PowerMethod::UpdateClaimedPower as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&UpdateClaimedPowerParams { raw_byte_delta: power_delta.raw, quality_adjusted_delta: power_delta.qa, }) .unwrap(), - )), + ), ..Default::default() }); } @@ -714,13 +714,11 @@ pub fn submit_windowed_post( if new_pow == PowerPair::zero() { subinvocs = Some(vec![]) } else { - let update_power_params = Some( - IpldBlock::serialize_cbor(&UpdateClaimedPowerParams { - raw_byte_delta: new_pow.raw, - quality_adjusted_delta: new_pow.qa, - }) - .unwrap(), - ); + let update_power_params = IpldBlock::serialize_cbor(&UpdateClaimedPowerParams { + raw_byte_delta: new_pow.raw, + quality_adjusted_delta: new_pow.qa, + }) + .unwrap(); subinvocs = Some(vec![ExpectInvocation { to: STORAGE_POWER_ACTOR_ADDR, method: PowerMethod::UpdateClaimedPower as u64, @@ -799,7 +797,7 @@ pub fn withdraw_balance( .unwrap(); if expect_withdraw_amount.is_positive() { - let withdraw_balance_params_se = Some(IpldBlock::serialize_cbor(¶ms).unwrap()); + let withdraw_balance_params_se = IpldBlock::serialize_cbor(¶ms).unwrap(); ExpectInvocation { from: Some(from), to: m_addr, @@ -869,11 +867,11 @@ pub fn verifreg_add_verifier(v: &VM, verifier: Address, data_cap: StoragePower) subinvocs: Some(vec![ExpectInvocation { to: VERIFIED_REGISTRY_ACTOR_ADDR, method: VerifregMethod::AddVerifier as u64, - params: Some(Some(IpldBlock::serialize_cbor(&add_verifier_params).unwrap())), + params: Some(IpldBlock::serialize_cbor(&add_verifier_params).unwrap()), subinvocs: Some(vec![ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::BalanceOf as u64, - params: Some(Some(IpldBlock::serialize_cbor(&verifier).unwrap())), + params: Some(IpldBlock::serialize_cbor(&verifier).unwrap()), code: Some(ExitCode::OK), ..Default::default() }]), @@ -901,14 +899,14 @@ pub fn verifreg_add_client(v: &VM, verifier: Address, client: Address, allowance subinvocs: Some(vec![ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::Mint as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&MintParams { to: client, amount: TokenAmount::from_whole(allowance), operators: vec![STORAGE_MARKET_ACTOR_ADDR], }) .unwrap(), - )), + ), code: Some(ExitCode::OK), ..Default::default() }]), @@ -966,14 +964,14 @@ pub fn verifreg_remove_expired_allocations( to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::Transfer as u64, code: Some(ExitCode::OK), - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&TransferParams { to: client, amount: TokenAmount::from_whole(datacap_refund), operator_data: Default::default(), }) .unwrap(), - )), + ), ..Default::default() }]), ..Default::default() @@ -1029,7 +1027,7 @@ pub fn datacap_extend_claim( to: VERIFIED_REGISTRY_ACTOR_ADDR, method: VerifregMethod::UniversalReceiverHook as u64, code: Some(ExitCode::OK), - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&UniversalReceiverParams { type_: FRC46_TOKEN_TYPE, payload: serialize( @@ -1046,14 +1044,14 @@ pub fn datacap_extend_claim( .unwrap(), }) .unwrap(), - )), + ), subinvocs: Some(vec![ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::Burn as u64, code: Some(ExitCode::OK), - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&BurnParams { amount: token_amount }).unwrap(), - )), + ), ..Default::default() }]), ..Default::default() @@ -1163,7 +1161,7 @@ pub fn market_publish_deal( expect_publish_invocs.push(ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::TransferFrom as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&TransferFromParams { from: deal_client, to: VERIFIED_REGISTRY_ACTOR_ADDR, @@ -1171,12 +1169,12 @@ pub fn market_publish_deal( operator_data: RawBytes::serialize(&alloc_reqs).unwrap(), }) .unwrap(), - )), + ), code: Some(ExitCode::OK), subinvocs: Some(vec![ExpectInvocation { to: VERIFIED_REGISTRY_ACTOR_ADDR, method: VerifregMethod::UniversalReceiverHook as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&UniversalReceiverParams { type_: FRC46_TOKEN_TYPE, payload: serialize( @@ -1193,7 +1191,7 @@ pub fn market_publish_deal( .unwrap(), }) .unwrap(), - )), + ), code: Some(ExitCode::OK), ..Default::default() }]), diff --git a/test_vm/tests/commit_post_test.rs b/test_vm/tests/commit_post_test.rs index 2c1a4ccee..6345ff1d9 100644 --- a/test_vm/tests/commit_post_test.rs +++ b/test_vm/tests/commit_post_test.rs @@ -70,7 +70,7 @@ fn setup(store: &'_ MemoryBlockstore) -> (VM<'_>, MinerInfo, SectorInfo) { // prove commit, cron, advance to post time let prove_params = ProveCommitSectorParams { sector_number, proof: vec![] }; - let prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + let prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_ok( &v, worker, @@ -476,7 +476,7 @@ fn aggregate_bad_sector_number() { sector_numbers: precommited_sector_nos, aggregate_proof: vec![], }; - let prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + let prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_code( &v, worker, @@ -555,7 +555,7 @@ fn aggregate_size_limits() { sector_numbers: precommited_sector_nos.clone(), aggregate_proof: vec![], }; - let mut prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + let mut prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_code( &v, worker, @@ -582,7 +582,7 @@ fn aggregate_size_limits() { sector_numbers: too_few_sector_nos_bf, aggregate_proof: vec![], }; - prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_code( &v, worker, @@ -610,7 +610,7 @@ fn aggregate_size_limits() { aggregate_proof: vec![0; policy.max_aggregated_proof_size + 1], }; - prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_code( &v, worker, @@ -686,7 +686,7 @@ fn aggregate_bad_sender() { sector_numbers: precommited_sector_nos, aggregate_proof: vec![], }; - let prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + let prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_code( &v, addrs[1], @@ -793,7 +793,7 @@ fn aggregate_one_precommit_expires() { let prove_params = ProveCommitAggregateParams { sector_numbers: sector_nos_bf, aggregate_proof: vec![] }; - let prove_params_ser = Some(IpldBlock::serialize_cbor(&prove_params).unwrap()); + let prove_params_ser = IpldBlock::serialize_cbor(&prove_params).unwrap(); apply_ok( &v, worker, diff --git a/test_vm/tests/extend_sectors_test.rs b/test_vm/tests/extend_sectors_test.rs index e568925fb..40aa61b8f 100644 --- a/test_vm/tests/extend_sectors_test.rs +++ b/test_vm/tests/extend_sectors_test.rs @@ -244,7 +244,7 @@ fn extend_legacy_sector_with_deals_inner(do_extend2: bool) { quality_adjusted_delta: StoragePower::from(-675 * (32i64 << 30) / 100), }; let mut expected_update_claimed_power_params_ser = - IpldBlock::serialize_cbor(&expected_update_claimed_power_params).unwrap(); + IpldBlock::serialize_cbor(&expected_update_claimed_power_params).unwrap().unwrap(); extend( &v, @@ -277,7 +277,7 @@ fn extend_legacy_sector_with_deals_inner(do_extend2: bool) { quality_adjusted_delta: StoragePower::from(-15 * (32i64 << 30) / 10), }; expected_update_claimed_power_params_ser = - IpldBlock::serialize_cbor(&expected_update_claimed_power_params).unwrap(); + IpldBlock::serialize_cbor(&expected_update_claimed_power_params).unwrap().unwrap(); extend( &v, diff --git a/test_vm/tests/power_scenario_tests.rs b/test_vm/tests/power_scenario_tests.rs index b4d65331d..8cb205ea5 100644 --- a/test_vm/tests/power_scenario_tests.rs +++ b/test_vm/tests/power_scenario_tests.rs @@ -63,7 +63,7 @@ fn create_miner_test() { // send to power actor to: STORAGE_POWER_ACTOR_ADDR, method: PowerMethod::CreateMiner as u64, - params: Some(Some(IpldBlock::serialize_cbor(¶ms).unwrap())), + params: Some(IpldBlock::serialize_cbor(¶ms).unwrap()), ret: Some(res.ret), subinvocs: Some(vec![ // request init actor construct miner @@ -74,7 +74,7 @@ fn create_miner_test() { // init then calls miner constructor to: Address::new_id(FIRST_TEST_USER_ADDR + 1), method: MinerMethod::Constructor as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&MinerConstructorParams { owner, worker: owner, @@ -84,7 +84,7 @@ fn create_miner_test() { multi_addresses: multiaddrs, }) .unwrap(), - )), + ), ..Default::default() }]), ..Default::default() diff --git a/test_vm/tests/publish_deals_test.rs b/test_vm/tests/publish_deals_test.rs index 66455d2d0..823037c00 100644 --- a/test_vm/tests/publish_deals_test.rs +++ b/test_vm/tests/publish_deals_test.rs @@ -555,13 +555,13 @@ fn psd_bad_sig() { ExpectInvocation { to: a.client1, method: AccountMethod::AuthenticateMessage as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&AuthenticateMessageParams { signature: invalid_sig_bytes, message: serialize(&proposal, "deal proposal").unwrap().to_vec(), }) .unwrap(), - )), + ), code: Some(ExitCode::USR_ILLEGAL_ARGUMENT), ..Default::default() }, diff --git a/test_vm/tests/replica_update_test.rs b/test_vm/tests/replica_update_test.rs index 4e9868495..1562a3cc1 100644 --- a/test_vm/tests/replica_update_test.rs +++ b/test_vm/tests/replica_update_test.rs @@ -1095,9 +1095,9 @@ fn replica_update_verified_deal() { ExpectInvocation { to: STORAGE_POWER_ACTOR_ADDR, method: PowerMethod::UpdateClaimedPower as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&expected_update_claimed_power_params).unwrap(), - )), + ), ..Default::default() }, ]), diff --git a/test_vm/tests/verifreg_remove_datacap_test.rs b/test_vm/tests/verifreg_remove_datacap_test.rs index e941ff137..299985a8e 100644 --- a/test_vm/tests/verifreg_remove_datacap_test.rs +++ b/test_vm/tests/verifreg_remove_datacap_test.rs @@ -65,11 +65,11 @@ fn remove_datacap_simple_successful_path() { ExpectInvocation { to: VERIFIED_REGISTRY_ACTOR_ADDR, method: VerifregMethod::AddVerifiedClient as u64, - params: Some(Some(IpldBlock::serialize_cbor(&add_verified_client_params).unwrap())), + params: Some(IpldBlock::serialize_cbor(&add_verified_client_params).unwrap()), subinvocs: Some(vec![ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::Mint as u64, - params: Some(Some(IpldBlock::serialize_cbor(&mint_params).unwrap())), + params: Some(IpldBlock::serialize_cbor(&mint_params).unwrap()), subinvocs: None, ..Default::default() }]), @@ -330,15 +330,13 @@ fn expect_remove_datacap(params: &RemoveDataCapParams) -> ExpectInvocation { ExpectInvocation { to: VERIFIED_REGISTRY_ACTOR_ADDR, method: VerifregMethod::RemoveVerifiedClientDataCap as u64, - params: Some(Some(IpldBlock::serialize_cbor(¶ms).unwrap())), + params: Some(IpldBlock::serialize_cbor(¶ms).unwrap()), code: Some(ExitCode::OK), subinvocs: Some(vec![ ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::BalanceOf as u64, - params: Some(Some( - IpldBlock::serialize_cbor(¶ms.verified_client_to_remove).unwrap(), - )), + params: Some(IpldBlock::serialize_cbor(¶ms.verified_client_to_remove).unwrap()), code: Some(ExitCode::OK), subinvocs: None, ..Default::default() @@ -346,7 +344,7 @@ fn expect_remove_datacap(params: &RemoveDataCapParams) -> ExpectInvocation { ExpectInvocation { to: DATACAP_TOKEN_ACTOR_ADDR, method: DataCapMethod::Destroy as u64, - params: Some(Some( + params: Some( IpldBlock::serialize_cbor(&DestroyParams { owner: params.verified_client_to_remove, amount: TokenAmount::from_whole( @@ -354,7 +352,7 @@ fn expect_remove_datacap(params: &RemoveDataCapParams) -> ExpectInvocation { ), }) .unwrap(), - )), + ), code: Some(ExitCode::OK), subinvocs: None, ..Default::default()